test(agent-smith): update filesystem tests to reflect new workspace directory approach

- Remove references to /proc filesystem in tests
- Update file paths to use WorkingArea/{InstanceID} pattern
- Add comprehensive tests for workspace directory discovery
- Add tests for signature-driven file matching with wildcards
- Test both direct file paths and wildcard patterns
- Verify proper handling of hidden directories and daemon directories
- All tests reflect the new signature-driven scanning approach

Co-authored-by: Ona <[email protected]>

Author: kylos101

components/ee/agent-smith/pkg/detector/filesystem_test.go

@@ -5,6 +5,8 @@
 package detector
 
 import (
+	"os"
+	"path/filepath"
 	"testing"
 	"time"
 
@@ -109,25 +111,25 @@ func TestFilesystemDetector_DisabledConfig(t *testing.T) {
 	}
 }
 
-func TestFilesystemFile_Fields(t *testing.T) {
+func TestFile_Fields(t *testing.T) {
 	workspace := &common.Workspace{
 		OwnerID:     "user123",
 		WorkspaceID: "ws456",
 		InstanceID:  "inst789",
 		GitURL:      "https://github.com/example/repo",
-		PID:         12345,
 	}
 
 	file := File{
-		Path:      "/proc/12345/root/workspace/config.json",
+		Path:      "/var/gitpod/workspaces/inst789/config.json",
 		Workspace: workspace,
 		Size:      1024,
 		ModTime:   time.Now(),
 	}
 
 	// Verify all fields are properly set
-	if file.Path != "/proc/12345/root/workspace/config.json" {
-		t.Errorf("Path = %q, expected %q", file.Path, "/proc/12345/root/workspace/config.json")
+	expectedPath := "/var/gitpod/workspaces/inst789/config.json"
+	if file.Path != expectedPath {
+		t.Errorf("Path = %q, expected %q", file.Path, expectedPath)
 	}
 	if file.Workspace != workspace {
 		t.Error("Workspace not properly set")
@@ -139,3 +141,208 @@ func TestFilesystemFile_Fields(t *testing.T) {
 		t.Error("ModTime should not be zero")
 	}
 }
+
+func TestWorkspaceDirectory_Fields(t *testing.T) {
+	wsDir := WorkspaceDirectory{
+		InstanceID: "inst789",
+		Path:       "/var/gitpod/workspaces/inst789",
+	}
+
+	if wsDir.InstanceID != "inst789" {
+		t.Errorf("InstanceID = %q, expected %q", wsDir.InstanceID, "inst789")
+	}
+
+	expectedPath := "/var/gitpod/workspaces/inst789"
+	if wsDir.Path != expectedPath {
+		t.Errorf("Path = %q, expected %q", wsDir.Path, expectedPath)
+	}
+}
+
+func TestFilesystemSignature_Fields(t *testing.T) {
+	sig := FilesystemSignature{
+		Name:      "config_files",
+		Filenames: []string{"*.conf", "config.json", ".env"},
+	}
+
+	if sig.Name != "config_files" {
+		t.Errorf("Name = %q, expected %q", sig.Name, "config_files")
+	}
+
+	expectedFilenames := []string{"*.conf", "config.json", ".env"}
+	if len(sig.Filenames) != len(expectedFilenames) {
+		t.Errorf("Filenames length = %d, expected %d", len(sig.Filenames), len(expectedFilenames))
+	}
+
+	for i, filename := range sig.Filenames {
+		if filename != expectedFilenames[i] {
+			t.Errorf("Filenames[%d] = %q, expected %q", i, filename, expectedFilenames[i])
+		}
+	}
+}
+
+func TestDiscoverWorkspaceDirectories(t *testing.T) {
+	// Create a temporary working area
+	tempDir, err := os.MkdirTemp("", "agent-smith-test-*")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create mock workspace directories
+	workspaceIDs := []string{"ws-abc123", "ws-def456", "ws-ghi789"}
+	for _, wsID := range workspaceIDs {
+		wsDir := filepath.Join(tempDir, wsID)
+		if err := os.Mkdir(wsDir, 0755); err != nil {
+			t.Fatalf("failed to create workspace dir %s: %v", wsDir, err)
+		}
+	}
+
+	// Create some files that should be ignored
+	if err := os.Mkdir(filepath.Join(tempDir, ".hidden"), 0755); err != nil {
+		t.Fatalf("failed to create hidden dir: %v", err)
+	}
+	if err := os.Mkdir(filepath.Join(tempDir, "ws-service-daemon"), 0755); err != nil {
+		t.Fatalf("failed to create daemon dir: %v", err)
+	}
+
+	// Create detector with temp working area
+	config := FilesystemScanningConfig{
+		Enabled:     true,
+		WorkingArea: tempDir,
+	}
+	detector, err := NewFilesystemDetector(config)
+	if err != nil {
+		t.Fatalf("failed to create detector: %v", err)
+	}
+
+	// Test workspace directory discovery
+	workspaceDirs, err := detector.discoverWorkspaceDirectories()
+	if err != nil {
+		t.Fatalf("failed to discover workspace directories: %v", err)
+	}
+
+	// Should find exactly 3 workspace directories (ignoring hidden and daemon dirs)
+	if len(workspaceDirs) != 3 {
+		t.Errorf("found %d workspace directories, expected 3", len(workspaceDirs))
+	}
+
+	// Verify the discovered directories
+	foundIDs := make(map[string]bool)
+	for _, wsDir := range workspaceDirs {
+		foundIDs[wsDir.InstanceID] = true
+
+		// Verify path is correct
+		expectedPath := filepath.Join(tempDir, wsDir.InstanceID)
+		if wsDir.Path != expectedPath {
+			t.Errorf("workspace %s path = %q, expected %q", wsDir.InstanceID, wsDir.Path, expectedPath)
+		}
+	}
+
+	// Verify all expected workspace IDs were found
+	for _, expectedID := range workspaceIDs {
+		if !foundIDs[expectedID] {
+			t.Errorf("workspace ID %q not found in discovered directories", expectedID)
+		}
+	}
+}
+
+func TestFindMatchingFiles(t *testing.T) {
+	// Create a temporary workspace directory
+	tempDir, err := os.MkdirTemp("", "agent-smith-workspace-*")
+	if err != nil {
+		t.Fatalf("failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create test files
+	testFiles := map[string]string{
+		"config.json":        `{"key": "value"}`,
+		"settings.conf":      `setting=value`,
+		"script.sh":          `#!/bin/bash\necho "hello"`,
+		"wallet.dat":         `wallet data`,
+		"normal.txt":         `just text`,
+		"subdir/nested.conf": `nested config`,
+	}
+
+	for filePath, content := range testFiles {
+		fullPath := filepath.Join(tempDir, filePath)
+
+		// Create directory if needed
+		if dir := filepath.Dir(fullPath); dir != tempDir {
+			if err := os.MkdirAll(dir, 0755); err != nil {
+				t.Fatalf("failed to create dir %s: %v", dir, err)
+			}
+		}
+
+		if err := os.WriteFile(fullPath, []byte(content), 0644); err != nil {
+			t.Fatalf("failed to create file %s: %v", fullPath, err)
+		}
+	}
+
+	// Create detector
+	config := FilesystemScanningConfig{
+		Enabled:     true,
+		WorkingArea: "/tmp", // Not used in this test
+	}
+	detector, err := NewFilesystemDetector(config)
+	if err != nil {
+		t.Fatalf("failed to create detector: %v", err)
+	}
+
+	tests := []struct {
+		name     string
+		pattern  string
+		expected []string
+	}{
+		{
+			name:     "direct file match",
+			pattern:  "config.json",
+			expected: []string{filepath.Join(tempDir, "config.json")},
+		},
+		{
+			name:     "wildcard pattern",
+			pattern:  "*.conf",
+			expected: []string{filepath.Join(tempDir, "settings.conf")},
+		},
+		{
+			name:     "shell script pattern",
+			pattern:  "*.sh",
+			expected: []string{filepath.Join(tempDir, "script.sh")},
+		},
+		{
+			name:     "no matches",
+			pattern:  "*.nonexistent",
+			expected: []string{},
+		},
+		{
+			name:     "nonexistent direct file",
+			pattern:  "missing.txt",
+			expected: []string{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			matches := detector.findMatchingFiles(tempDir, tt.pattern)
+
+			if len(matches) != len(tt.expected) {
+				t.Errorf("found %d matches, expected %d", len(matches), len(tt.expected))
+				t.Errorf("matches: %v", matches)
+				t.Errorf("expected: %v", tt.expected)
+				return
+			}
+
+			// Convert to map for easier comparison
+			matchMap := make(map[string]bool)
+			for _, match := range matches {
+				matchMap[match] = true
+			}
+
+			for _, expected := range tt.expected {
+				if !matchMap[expected] {
+					t.Errorf("expected match %q not found", expected)
+				}
+			}
+		})
+	}
+}