fix: send the correct limitToFiles to the incremental scan [IDE-402] (#58)

Author: teodora-sandu

internal/analysis/analysis.go

@@ -241,7 +241,7 @@ func (a *analysisOrchestrator) RunIncrementalAnalysis(ctx context.Context, orgId
 	org := uuid.MustParse(orgId)
 
 	host := a.host(false)
-	a.logger.Debug().Str("host", host).Str("workspaceId", workspaceId).Msg("starting scan")
+	a.logger.Debug().Str("host", host).Str("workspaceId", workspaceId).Interface("limitToFiles", limitToFiles).Msg("starting scan")
 
 	client, err := orchestrationClient.NewClientWithResponses(host, orchestrationClient.WithHTTPClient(a.httpClient))
 	if err != nil {

internal/bundle/bundle.go

@@ -31,6 +31,7 @@ type Bundle interface {
 	GetBundleHash() string
 	GetFiles() map[string]deepcode.BundleFile
 	GetMissingFiles() []string
+	GetLimitToFiles() []string
 	GetRootPath() string
 }
 
@@ -84,6 +85,10 @@ func (b *deepCodeBundle) GetMissingFiles() []string {
 	return b.missingFiles
 }
 
+func (b *deepCodeBundle) GetLimitToFiles() []string {
+	return b.limitToFiles
+}
+
 func (b *deepCodeBundle) GetRootPath() string {
 	return b.rootPath
 }

internal/bundle/bundle_manager_test.go

@@ -236,7 +236,7 @@ func Test_Create(t *testing.T) {
 		assert.Contains(t, bundle.GetFiles(), relativePath)
 	})
 
-	t.Run("url-encodes files", func(t *testing.T) {
+	t.Run("url-encoded files", func(t *testing.T) {
 		ctrl := gomock.NewController(t)
 		mockSpan := mocks.NewMockSpan(ctrl)
 		mockSpan.EXPECT().Context().AnyTimes()
@@ -289,6 +289,64 @@ func Test_Create(t *testing.T) {
 			assert.Contains(t, bundle.GetFiles(), expectedPath)
 		}
 	})
+
+	t.Run("includes changed files into limit to files", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		mockSpan := mocks.NewMockSpan(ctrl)
+		mockSpan.EXPECT().Context().AnyTimes()
+		mockSnykCodeClient := deepcodeMocks.NewMockDeepcodeClient(ctrl)
+		mockSnykCodeClient.EXPECT().GetFilters(gomock.Any()).Return(deepcode.FiltersResponse{
+			ConfigFiles: []string{},
+			Extensions:  []string{".java"},
+		}, nil)
+		mockSnykCodeClient.EXPECT().CreateBundle(gomock.Any(), map[string]string{
+			"path/to/file1.java":            "9c05690c5b8e22df259431c95df33d01267f799de6810382ada1a9ff1b89710e",
+			"path/with%20spaces/file2.java": "9c05690c5b8e22df259431c95df33d01267f799de6810382ada1a9ff1b89710e",
+		}).Times(1)
+		mockInstrumentor := mocks.NewMockInstrumentor(ctrl)
+		mockInstrumentor.EXPECT().StartSpan(gomock.Any(), gomock.Any()).Return(mockSpan).AnyTimes()
+		mockInstrumentor.EXPECT().Finish(gomock.Any()).AnyTimes()
+		mockErrorReporter := mocks.NewMockErrorReporter(ctrl)
+		mockTracker := trackerMocks.NewMockTracker(ctrl)
+		mockTracker.EXPECT().Begin(gomock.Eq("Creating file bundle"), gomock.Eq("Checking and adding files for analysis")).Return()
+		mockTracker.EXPECT().End(gomock.Eq("")).Return()
+		mockTrackerFactory := trackerMocks.NewMockTrackerFactory(ctrl)
+		mockTrackerFactory.EXPECT().GenerateTracker().Return(mockTracker)
+
+		filesRelPaths := []string{
+			"path/to/file1.java",
+			"path/with spaces/file2.java",
+		}
+		expectedPaths := []string{
+			"path/to/file1.java",
+		}
+
+		tempDir := t.TempDir()
+		var filesFullPaths []string
+		for _, fileRelPath := range filesRelPaths {
+			file := filepath.Join(tempDir, fileRelPath)
+			filesFullPaths = append(filesFullPaths, file)
+			_ = os.MkdirAll(filepath.Dir(file), 0700)
+			err := os.WriteFile(file, []byte("some content so the file won't be skipped"), 0600)
+			require.NoError(t, err)
+		}
+
+		var bundleManager = bundle.NewBundleManager(mockSnykCodeClient, newLogger(t), mockInstrumentor, mockErrorReporter, mockTrackerFactory)
+		bundle, err := bundleManager.Create(context.Background(),
+			"testRequestId",
+			tempDir,
+			sliceToChannel(filesFullPaths),
+			map[string]bool{
+				filesFullPaths[0]: true,
+			})
+		require.NoError(t, err)
+		for _, expectedPath := range expectedPaths {
+			assert.Contains(t, bundle.GetFiles(), expectedPath)
+		}
+		for _, expectedPath := range expectedPaths {
+			assert.Contains(t, bundle.GetLimitToFiles(), expectedPath)
+		}
+	})
 }
 
 func Test_Upload(t *testing.T) {

internal/bundle/mocks/bundle.go

@@ -125,6 +125,7 @@ func NewCodeScanner(
 		analysis.WithInstrumentor(scanner.instrumentor),
 		analysis.WithErrorReporter(scanner.errorReporter),
 		analysis.WithTrackerFactory(scanner.trackerFactory),
+		analysis.WithLogger(scanner.logger),
 		analysis.WithFlow(scanner.flow),
 	)
 	scanner.analysisOrchestrator = analysisOrchestrator
@@ -214,11 +215,8 @@ func (c *codeScanner) UploadAndAnalyze(
 			return nil, bundleHash, nil
 		}
 	}
-	var limitToFiles []string
-	for file := range changedFiles {
-		limitToFiles = append(limitToFiles, file)
-	}
-	response, err := c.analysisOrchestrator.RunIncrementalAnalysis(ctx, c.config.Organization(), b.GetRootPath(), workspaceId, limitToFiles)
+
+	response, err := c.analysisOrchestrator.RunIncrementalAnalysis(ctx, c.config.Organization(), b.GetRootPath(), workspaceId, b.GetLimitToFiles())
 
 	if ctx.Err() != nil {
 		c.logger.Info().Msg("Canceling Code scan - Code scanner received cancellation signal")

internal/workspace/2024-05-14/client.go

@@ -105,7 +105,7 @@ func Test_UploadAndAnalyze(t *testing.T) {
 				"4a72d1db-b465-4764-99e1-ecedad03b06a",
 				"testRootPath",
 				"c172d1db-b465-4764-99e1-ecedad03b06a",
-				gomock.Any(),
+				[]string{},
 			).Return(&sarif.SarifResponse{Status: "COMPLETE"}, nil)
 
 			codeScanner := codeclient.NewCodeScanner(
@@ -126,6 +126,43 @@ func Test_UploadAndAnalyze(t *testing.T) {
 			assert.Equal(t, "testBundleHash", bundleHash)
 		},
 	)
+
+	t.Run(
+		"should send the changed files to the analysis", func(t *testing.T) {
+			relativeChangedFile := "./nested/folder/nested/file.ts"
+
+			mockBundle := bundle.NewBundle(deepcodeMocks.NewMockDeepcodeClient(ctrl), mockInstrumentor, mockErrorReporter, &logger, "testRootPath", "testBundleHash", files, []string{relativeChangedFile}, []string{})
+			mockBundleManager := bundleMocks.NewMockBundleManager(ctrl)
+			mockBundleManager.EXPECT().Create(gomock.Any(), "b372d1db-b465-4764-99e1-ecedad03b06a", baseDir, gomock.Any(), map[string]bool{}).Return(mockBundle, nil)
+			mockBundleManager.EXPECT().Upload(gomock.Any(), "b372d1db-b465-4764-99e1-ecedad03b06a", mockBundle, files).Return(mockBundle, nil)
+
+			mockAnalysisOrchestrator := mockAnalysis.NewMockAnalysisOrchestrator(ctrl)
+			mockAnalysisOrchestrator.EXPECT().CreateWorkspace(gomock.Any(), "4a72d1db-b465-4764-99e1-ecedad03b06a", "b372d1db-b465-4764-99e1-ecedad03b06a", target, "testBundleHash").Return("c172d1db-b465-4764-99e1-ecedad03b06a", nil)
+			mockAnalysisOrchestrator.EXPECT().RunIncrementalAnalysis(
+				gomock.Any(),
+				"4a72d1db-b465-4764-99e1-ecedad03b06a",
+				"testRootPath",
+				"c172d1db-b465-4764-99e1-ecedad03b06a",
+				[]string{relativeChangedFile},
+			).Return(&sarif.SarifResponse{Status: "COMPLETE"}, nil)
+
+			codeScanner := codeclient.NewCodeScanner(
+				mockConfig,
+				mockHTTPClient,
+				codeclient.WithTrackerFactory(mockTrackerFactory),
+				codeclient.WithInstrumentor(mockInstrumentor),
+				codeclient.WithErrorReporter(mockErrorReporter),
+				codeclient.WithLogger(&logger),
+			)
+
+			response, _, err := codeScanner.
+				WithBundleManager(mockBundleManager).
+				WithAnalysisOrchestrator(mockAnalysisOrchestrator).
+				UploadAndAnalyze(context.Background(), "b372d1db-b465-4764-99e1-ecedad03b06a", target, docs, map[string]bool{})
+			require.NoError(t, err)
+			assert.Equal(t, "COMPLETE", response.Status)
+		},
+	)
 }
 
 func setupDocs(t *testing.T) (string, string, string, []byte, []byte) {