Expanded test isolation for branches.

Adds comprehensive tests to verify branch isolation:

Improves test coverage for separate collections per branch
Ensures search results originate only from the active branch
Verifies correct data persistence when switching branches
Implements additional cleanup logic between tests
These enhancements ensure reliable separation of vector indexes across development branches.

Author: yavpungggi

src/services/code-index/vector-store/__tests__/qdrant-client.branch-isolation.spec.ts

@@ -27,11 +27,12 @@ describe("QdrantVectorStore - Branch Isolation", () => {
 		// Setup mock Qdrant client
 		mockQdrantClient = {
 			getCollections: vi.fn().mockResolvedValue({ collections: [] }),
-			getCollection: vi.fn().mockResolvedValue(null),
+			getCollection: vi.fn().mockResolvedValue({ vectors_count: 1 }),
 			createCollection: vi.fn().mockResolvedValue(true),
 			deleteCollection: vi.fn().mockResolvedValue(true),
 			upsert: vi.fn().mockResolvedValue({ status: "completed" }),
 			search: vi.fn().mockResolvedValue([]),
+			query: vi.fn().mockResolvedValue({ points: [] }),
 			delete: vi.fn().mockResolvedValue({ status: "completed" }),
 		}
 
@@ -93,6 +94,28 @@ describe("QdrantVectorStore - Branch Isolation", () => {
 	})
 
 	describe("collection naming with branch isolation", () => {
+		beforeEach(() => {
+			// Clear all mocks before each test in this suite to prevent cache pollution
+			vi.clearAllMocks()
+			mockedGetCurrentBranch.mockClear()
+
+			// Ensure vectorStore is undefined to force new instance creation
+			vectorStore = undefined as any
+
+			// Reset the mock Qdrant client to ensure clean state for each test
+			mockQdrantClient = {
+				getCollections: vi.fn().mockResolvedValue({ collections: [] }),
+				getCollection: vi.fn().mockResolvedValue(null),
+				createCollection: vi.fn().mockResolvedValue(true),
+				deleteCollection: vi.fn().mockResolvedValue(true),
+				upsert: vi.fn().mockResolvedValue({ status: "completed" }),
+				search: vi.fn().mockResolvedValue([]),
+				query: vi.fn().mockResolvedValue({ points: [] }),
+				delete: vi.fn().mockResolvedValue({ status: "completed" }),
+			}
+			vi.mocked(QdrantClient).mockImplementation(() => mockQdrantClient)
+		})
+
 		it("should create branch-specific collection name when branch is provided", async () => {
 			mockedGetCurrentBranch.mockResolvedValue("feature-branch")
 
@@ -167,6 +190,10 @@ describe("QdrantVectorStore - Branch Isolation", () => {
 		})
 
 		it("should handle detached HEAD (undefined branch)", async () => {
+			// Clear any cached branch from previous tests and reset mock
+			mockedGetCurrentBranch.mockClear()
+			mockedGetCurrentBranch.mockResolvedValue(undefined as any)
+
 			vectorStore = new QdrantVectorStore(
 				testWorkspacePath,
 				testQdrantUrl,
@@ -248,7 +275,7 @@ describe("QdrantVectorStore - Branch Isolation", () => {
 	})
 
 	describe("getCurrentBranch method", () => {
-		it("should return current branch when branch isolation is enabled", () => {
+		it("should return current branch when branch isolation is enabled", async () => {
 			vectorStore = new QdrantVectorStore(
 				testWorkspacePath,
 				testQdrantUrl,
@@ -258,6 +285,10 @@ describe("QdrantVectorStore - Branch Isolation", () => {
 				"main",
 			)
 
+			// Need to initialize to set currentBranch
+			mockQdrantClient.getCollection.mockResolvedValue({ vectors_count: 0 })
+			await vectorStore.initialize()
+
 			expect(vectorStore.getCurrentBranch()).toBe("main")
 		})
 
@@ -326,4 +357,200 @@ describe("QdrantVectorStore - Branch Isolation", () => {
 			expect(mockedGetCurrentBranch).toHaveBeenCalledWith(testWorkspacePath)
 		})
 	})
+
+	describe("cross-branch search isolation", () => {
+		it("should not return results from other branch collections when searching", async () => {
+			// Setup: Create vector store on main branch
+			mockedGetCurrentBranch.mockResolvedValue("main")
+			vectorStore = new QdrantVectorStore(
+				testWorkspacePath,
+				testQdrantUrl,
+				testVectorSize,
+				undefined,
+				true,
+				"main",
+			)
+
+			// Mock collection doesn't exist initially, then exists after creation
+			mockQdrantClient.getCollection.mockResolvedValueOnce(null)
+			mockQdrantClient.getCollection.mockResolvedValue({ vectors_count: 1 })
+			await vectorStore.initialize()
+
+			// Capture the collection name used for main branch
+			const mainCollectionCall = mockQdrantClient.createCollection.mock.calls[0]
+			const mainCollectionName = mainCollectionCall[0]
+			expect(mainCollectionName).toMatch(/^ws-[a-f0-9]+-br-main$/)
+
+			// Index documents on main branch
+			const mainDocs = [
+				{
+					id: "main-doc-1",
+					vector: [1, 0, 0],
+					payload: { path: "main.ts", content: "main branch code" },
+				},
+			]
+			await vectorStore.upsertPoints(mainDocs)
+
+			// Verify upsert was called with main collection
+			expect(mockQdrantClient.upsert).toHaveBeenCalledWith(
+				mainCollectionName,
+				expect.objectContaining({
+					points: expect.arrayContaining([
+						expect.objectContaining({
+							id: "main-doc-1",
+							payload: expect.objectContaining({ path: "main.ts" }),
+						}),
+					]),
+				}),
+			)
+
+			// Switch to feature branch
+			vi.clearAllMocks()
+			vectorStore.invalidateBranchCache()
+			mockedGetCurrentBranch.mockResolvedValue("feature-branch")
+
+			// Re-initialize for feature branch - collection doesn't exist, then exists
+			mockQdrantClient.getCollection.mockResolvedValueOnce(null)
+			mockQdrantClient.getCollection.mockResolvedValue({ vectors_count: 1 })
+			await vectorStore.initialize()
+
+			// Capture the collection name used for feature branch
+			const featureCollectionCall = mockQdrantClient.createCollection.mock.calls[0]
+			const featureCollectionName = featureCollectionCall[0]
+			expect(featureCollectionName).toMatch(/^ws-[a-f0-9]+-br-feature-branch$/)
+
+			// Verify different collection names
+			expect(featureCollectionName).not.toBe(mainCollectionName)
+
+			// Index different documents on feature branch
+			const featureDocs = [
+				{
+					id: "feature-doc-1",
+					vector: [0, 1, 0],
+					payload: { path: "feature.ts", content: "feature branch code" },
+				},
+			]
+			await vectorStore.upsertPoints(featureDocs)
+
+			// Verify upsert was called with feature collection
+			expect(mockQdrantClient.upsert).toHaveBeenCalledWith(
+				featureCollectionName,
+				expect.objectContaining({
+					points: expect.arrayContaining([
+						expect.objectContaining({
+							id: "feature-doc-1",
+							payload: expect.objectContaining({ path: "feature.ts" }),
+						}),
+					]),
+				}),
+			)
+
+			// Mock search results - feature branch should only return feature docs
+			mockQdrantClient.query.mockResolvedValue({
+				points: [
+					{
+						id: "feature-doc-1",
+						score: 0.95,
+						payload: {
+							filePath: "feature.ts",
+							codeChunk: "feature branch code",
+							startLine: 1,
+							endLine: 10,
+						},
+					},
+				],
+			})
+
+			// Search on feature branch
+			const searchResults = await vectorStore.search([0, 1, 0])
+
+			// Verify search was called with feature collection, not main
+			expect(mockQdrantClient.query).toHaveBeenCalledWith(
+				featureCollectionName,
+				expect.objectContaining({
+					query: [0, 1, 0],
+				}),
+			)
+
+			// Verify results are from feature branch only
+			expect(searchResults).toHaveLength(1)
+			expect(searchResults[0].payload.filePath).toBe("feature.ts")
+			expect(searchResults[0].payload.codeChunk).toBe("feature branch code")
+
+			// Verify main branch document is NOT in results
+			expect(searchResults).not.toContainEqual(
+				expect.objectContaining({
+					payload: expect.objectContaining({ filePath: "main.ts" }),
+				}),
+			)
+		})
+
+		it("should maintain separate indexes when switching back to previous branch", async () => {
+			// Start on main branch
+			mockedGetCurrentBranch.mockResolvedValue("main")
+			vectorStore = new QdrantVectorStore(
+				testWorkspacePath,
+				testQdrantUrl,
+				testVectorSize,
+				undefined,
+				true,
+				"main",
+			)
+
+			// Collection doesn't exist initially, then exists after creation
+			mockQdrantClient.getCollection.mockResolvedValueOnce(null)
+			mockQdrantClient.getCollection.mockResolvedValue({ vectors_count: 1 })
+			await vectorStore.initialize()
+			const mainCollectionName = mockQdrantClient.createCollection.mock.calls[0][0]
+
+			// Index on main
+			await vectorStore.upsertPoints([{ id: "main-1", vector: [1, 0, 0], payload: { path: "main.ts" } }])
+
+			// Switch to feature branch
+			vi.clearAllMocks()
+			vectorStore.invalidateBranchCache()
+			mockedGetCurrentBranch.mockResolvedValue("feature")
+			// Collection doesn't exist initially, then exists after creation
+			mockQdrantClient.getCollection.mockResolvedValueOnce(null)
+			mockQdrantClient.getCollection.mockResolvedValue({ vectors_count: 1 })
+			await vectorStore.initialize()
+			const featureCollectionName = mockQdrantClient.createCollection.mock.calls[0][0]
+
+			// Index on feature
+			await vectorStore.upsertPoints([{ id: "feature-1", vector: [0, 1, 0], payload: { path: "feature.ts" } }])
+
+			// Switch back to main
+			vi.clearAllMocks()
+			vectorStore.invalidateBranchCache()
+			mockedGetCurrentBranch.mockResolvedValue("main")
+
+			// Mock that main collection already exists
+			mockQdrantClient.getCollection.mockResolvedValue({ vectors_count: 1 })
+			await vectorStore.initialize()
+
+			// Mock search returns main branch docs
+			mockQdrantClient.query.mockResolvedValue({
+				points: [
+					{
+						id: "main-1",
+						score: 0.95,
+						payload: {
+							filePath: "main.ts",
+							codeChunk: "main branch code",
+							startLine: 1,
+							endLine: 10,
+						},
+					},
+				],
+			})
+
+			const results = await vectorStore.search([1, 0, 0])
+
+			// Should search in main collection
+			expect(mockQdrantClient.query).toHaveBeenCalledWith(mainCollectionName, expect.any(Object))
+
+			// Should get main branch results
+			expect(results[0].payload.filePath).toBe("main.ts")
+		})
+	})
 })