mcp-server-azure-devops 1.1.0

package/dist/features/search/search-code/feature.spec.unit.js

@@ -0,0 +1,963 @@
+import axios from 'axios';
+import { searchCode } from './feature';
+import { AzureDevOpsError } from '../../../shared/errors';
+import { GitVersionType } from 'azure-devops-node-api/interfaces/GitInterfaces';
+// Mock Azure Identity
+jest.mock('@azure/identity', () => {
+    const mockGetToken = jest.fn().mockResolvedValue({ token: 'mock-token' });
+    return {
+        DefaultAzureCredential: jest.fn().mockImplementation(() => ({
+            getToken: mockGetToken,
+        })),
+        AzureCliCredential: jest.fn().mockImplementation(() => ({
+            getToken: mockGetToken,
+        })),
+    };
+});
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios;
+describe('searchCode unit', () => {
+    // Mock WebApi connection
+    const mockConnection = {
+        getGitApi: jest.fn().mockImplementation(() => ({
+            getItemContent: jest.fn().mockImplementation((_repoId, path) => {
+                // Return different content based on the path to simulate different files
+                if (path === '/src/example.ts') {
+                    return Buffer.from('export function example() { return "test"; }');
+                }
+                return Buffer.from('// Empty file');
+            }),
+        })),
+        _getHttpClient: jest.fn().mockReturnValue({
+            getAuthorizationHeader: jest.fn().mockReturnValue('Bearer mock-token'),
+        }),
+        getCoreApi: jest.fn().mockImplementation(() => ({
+            getProjects: jest
+                .fn()
+                .mockResolvedValue([{ name: 'TestProject', id: 'project-id' }]),
+        })),
+        serverUrl: 'https://dev.azure.com/testorg',
+    };
+    // Store original console.error
+    const originalConsoleError = console.error;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // Mock console.error to prevent error messages from being displayed during tests
+        console.error = jest.fn();
+    });
+    afterEach(() => {
+        // Restore original console.error
+        console.error = originalConsoleError;
+    });
+    test('should return search results with content', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 1,
+                results: [
+                    {
+                        fileName: 'example.ts',
+                        path: '/src/example.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash',
+                            },
+                        ],
+                        contentId: 'content-hash',
+                    },
+                ],
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Create a mock stream with content
+        const fileContent = 'export function example() { return "test"; }';
+        const mockStream = {
+            on: jest.fn().mockImplementation((event, callback) => {
+                if (event === 'data') {
+                    // Call the callback with the data
+                    callback(Buffer.from(fileContent));
+                }
+                else if (event === 'end') {
+                    // Call the end callback asynchronously
+                    setTimeout(callback, 0);
+                }
+                return mockStream; // Return this for chaining
+            }),
+        };
+        // Mock Git API to return content
+        const mockGitApi = {
+            getItemContent: jest.fn().mockResolvedValue(mockStream),
+        };
+        const mockConnectionWithContent = {
+            ...mockConnection,
+            getGitApi: jest.fn().mockResolvedValue(mockGitApi),
+            serverUrl: 'https://dev.azure.com/testorg',
+        };
+        // Act
+        const result = await searchCode(mockConnectionWithContent, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            includeContent: true,
+        });
+        // Assert
+        expect(result).toBeDefined();
+        expect(result.count).toBe(1);
+        expect(result.results).toHaveLength(1);
+        expect(result.results[0].fileName).toBe('example.ts');
+        expect(result.results[0].content).toBe('export function example() { return "test"; }');
+        expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+        expect(mockGitApi.getItemContent).toHaveBeenCalledTimes(1);
+        expect(mockGitApi.getItemContent).toHaveBeenCalledWith('repo-id', '/src/example.ts', 'TestProject', undefined, undefined, undefined, undefined, false, {
+            version: 'commit-hash',
+            versionType: GitVersionType.Commit,
+        }, true);
+    });
+    test('should use organizationId override for services search', async () => {
+        mockedAxios.post.mockResolvedValueOnce({
+            data: {
+                count: 0,
+                results: [],
+            },
+        });
+        await searchCode(mockConnection, {
+            searchText: 'override',
+            projectId: 'ProjectX',
+            organizationId: 'override-org',
+        });
+        expect(mockedAxios.post).toHaveBeenCalledWith('https://almsearch.dev.azure.com/override-org/ProjectX/_apis/search/codesearchresults?api-version=7.1', expect.any(Object), expect.any(Object));
+    });
+    test('should build server search URL when using Azure DevOps Server', async () => {
+        const serverConnection = {
+            ...mockConnection,
+            serverUrl: 'https://ado.local/tfs/DefaultCollection',
+        };
+        mockedAxios.post.mockResolvedValueOnce({
+            data: {
+                count: 0,
+                results: [],
+            },
+        });
+        await searchCode(serverConnection, {
+            searchText: 'server',
+            projectId: 'ProjectX',
+        });
+        expect(mockedAxios.post).toHaveBeenCalledWith('https://ado.local/tfs/DefaultCollection/ProjectX/_apis/search/codesearchresults?api-version=7.1', expect.any(Object), expect.any(Object));
+    });
+    test('should not fetch content when includeContent is false', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 1,
+                results: [
+                    {
+                        fileName: 'example.ts',
+                        path: '/src/example.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash',
+                            },
+                        ],
+                        contentId: 'content-hash',
+                    },
+                ],
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Act
+        const result = await searchCode(mockConnection, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            includeContent: false,
+        });
+        // Assert
+        expect(result).toBeDefined();
+        expect(result.count).toBe(1);
+        expect(result.results).toHaveLength(1);
+        expect(result.results[0].fileName).toBe('example.ts');
+        expect(result.results[0].content).toBeUndefined();
+        expect(mockConnection.getGitApi).not.toHaveBeenCalled();
+    });
+    test('should handle empty search results', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 0,
+                results: [],
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Act
+        const result = await searchCode(mockConnection, {
+            searchText: 'nonexistent',
+            projectId: 'TestProject',
+        });
+        // Assert
+        expect(result).toBeDefined();
+        expect(result.count).toBe(0);
+        expect(result.results).toHaveLength(0);
+    });
+    test('should handle API errors', async () => {
+        // Arrange
+        const axiosError = new Error('API Error');
+        axiosError.isAxiosError = true;
+        axiosError.response = {
+            status: 404,
+            data: {
+                message: 'Project not found',
+            },
+        };
+        mockedAxios.post.mockRejectedValueOnce(axiosError);
+        // Act & Assert
+        await expect(searchCode(mockConnection, {
+            searchText: 'example',
+            projectId: 'NonExistentProject',
+        })).rejects.toThrow(AzureDevOpsError);
+    });
+    test('should propagate custom errors when thrown internally', async () => {
+        // Arrange
+        const customError = new AzureDevOpsError('Custom error');
+        // Mock axios to properly return the custom error
+        mockedAxios.post.mockImplementationOnce(() => {
+            throw customError;
+        });
+        // Act & Assert
+        await expect(searchCode(mockConnection, {
+            searchText: 'example',
+            projectId: 'TestProject',
+        })).rejects.toThrow(AzureDevOpsError);
+        // Reset mock and set it up again for the second test
+        mockedAxios.post.mockReset();
+        mockedAxios.post.mockImplementationOnce(() => {
+            throw customError;
+        });
+        await expect(searchCode(mockConnection, {
+            searchText: 'example',
+            projectId: 'TestProject',
+        })).rejects.toThrow('Custom error');
+    });
+    test('should apply filters when provided', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 1,
+                results: [
+                    {
+                        fileName: 'example.ts',
+                        path: '/src/example.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash',
+                            },
+                        ],
+                        contentId: 'content-hash',
+                    },
+                ],
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Act
+        await searchCode(mockConnection, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            filters: {
+                Repository: ['TestRepo'],
+                Path: ['/src'],
+                Branch: ['main'],
+                CodeElement: ['function'],
+            },
+        });
+        // Assert
+        expect(mockedAxios.post).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            filters: {
+                Project: ['TestProject'],
+                Repository: ['TestRepo'],
+                Path: ['/src'],
+                Branch: ['main'],
+                CodeElement: ['function'],
+            },
+        }), expect.any(Object));
+    });
+    test('should handle pagination parameters', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 100,
+                results: Array(10)
+                    .fill(0)
+                    .map((_, i) => ({
+                    fileName: `example${i}.ts`,
+                    path: `/src/example${i}.ts`,
+                    matches: {
+                        content: [
+                            {
+                                charOffset: 17,
+                                length: 7,
+                            },
+                        ],
+                    },
+                    collection: {
+                        name: 'DefaultCollection',
+                    },
+                    project: {
+                        name: 'TestProject',
+                        id: 'project-id',
+                    },
+                    repository: {
+                        name: 'TestRepo',
+                        id: 'repo-id',
+                        type: 'git',
+                    },
+                    versions: [
+                        {
+                            branchName: 'main',
+                            changeId: 'commit-hash',
+                        },
+                    ],
+                    contentId: `content-hash-${i}`,
+                })),
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Act
+        await searchCode(mockConnection, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            top: 10,
+            skip: 20,
+        });
+        // Assert
+        expect(mockedAxios.post).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            $top: 10,
+            $skip: 20,
+        }), expect.any(Object));
+    });
+    test('should handle errors when fetching file content', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 1,
+                results: [
+                    {
+                        fileName: 'example.ts',
+                        path: '/src/example.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash',
+                            },
+                        ],
+                        contentId: 'content-hash',
+                    },
+                ],
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Mock Git API to throw an error
+        const mockGitApi = {
+            getItemContent: jest
+                .fn()
+                .mockRejectedValue(new Error('Failed to fetch content')),
+        };
+        const mockConnectionWithError = {
+            ...mockConnection,
+            getGitApi: jest.fn().mockResolvedValue(mockGitApi),
+        };
+        // Act
+        const result = await searchCode(mockConnectionWithError, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            includeContent: true,
+        });
+        // Assert
+        expect(result).toBeDefined();
+        expect(result.count).toBe(1);
+        expect(result.results).toHaveLength(1);
+        // Content should be undefined when there's an error fetching it
+        expect(result.results[0].content).toBeUndefined();
+    });
+    test('should use default project when projectId is not provided', async () => {
+        // Arrange
+        // Set up environment variable for default project
+        const originalEnv = process.env.AZURE_DEVOPS_DEFAULT_PROJECT;
+        process.env.AZURE_DEVOPS_DEFAULT_PROJECT = 'DefaultProject';
+        const mockSearchResponse = {
+            data: {
+                count: 2,
+                results: [
+                    {
+                        fileName: 'example1.ts',
+                        path: '/src/example1.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'DefaultProject',
+                            id: 'default-project-id',
+                        },
+                        repository: {
+                            name: 'Repo1',
+                            id: 'repo-id-1',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash-1',
+                            },
+                        ],
+                        contentId: 'content-hash-1',
+                    },
+                    {
+                        fileName: 'example2.ts',
+                        path: '/src/example2.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'DefaultProject',
+                            id: 'default-project-id',
+                        },
+                        repository: {
+                            name: 'Repo2',
+                            id: 'repo-id-2',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash-2',
+                            },
+                        ],
+                        contentId: 'content-hash-2',
+                    },
+                ],
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        try {
+            // Act
+            const result = await searchCode(mockConnection, {
+                searchText: 'example',
+                includeContent: false,
+            });
+            // Assert
+            expect(result).toBeDefined();
+            expect(result.count).toBe(2);
+            expect(result.results).toHaveLength(2);
+            expect(result.results[0].project.name).toBe('DefaultProject');
+            expect(result.results[1].project.name).toBe('DefaultProject');
+            expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+            expect(mockedAxios.post).toHaveBeenCalledWith(expect.stringContaining('https://almsearch.dev.azure.com/testorg/DefaultProject/_apis/search/codesearchresults'), expect.objectContaining({
+                filters: expect.objectContaining({
+                    Project: ['DefaultProject'],
+                }),
+            }), expect.any(Object));
+        }
+        finally {
+            // Restore original environment variable
+            process.env.AZURE_DEVOPS_DEFAULT_PROJECT = originalEnv;
+        }
+    });
+    test('should throw error when no projectId is provided and no default project is set', async () => {
+        // Arrange
+        // Ensure no default project is set
+        const originalEnv = process.env.AZURE_DEVOPS_DEFAULT_PROJECT;
+        process.env.AZURE_DEVOPS_DEFAULT_PROJECT = '';
+        try {
+            // Act & Assert
+            await expect(searchCode(mockConnection, {
+                searchText: 'example',
+                includeContent: false,
+            })).rejects.toThrow('Project ID is required');
+        }
+        finally {
+            // Restore original environment variable
+            process.env.AZURE_DEVOPS_DEFAULT_PROJECT = originalEnv;
+        }
+    });
+    test('should handle includeContent for different content types', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 4,
+                results: [
+                    // Result 1 - Buffer content
+                    {
+                        fileName: 'example1.ts',
+                        path: '/src/example1.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id-1',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash-1',
+                            },
+                        ],
+                        contentId: 'content-hash-1',
+                    },
+                    // Result 2 - String content
+                    {
+                        fileName: 'example2.ts',
+                        path: '/src/example2.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id-2',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash-2',
+                            },
+                        ],
+                        contentId: 'content-hash-2',
+                    },
+                    // Result 3 - Object content
+                    {
+                        fileName: 'example3.ts',
+                        path: '/src/example3.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id-3',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash-3',
+                            },
+                        ],
+                        contentId: 'content-hash-3',
+                    },
+                    // Result 4 - Uint8Array content
+                    {
+                        fileName: 'example4.ts',
+                        path: '/src/example4.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id-4',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash-4',
+                            },
+                        ],
+                        contentId: 'content-hash-4',
+                    },
+                ],
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Create mock contents for each type - all as streams, since that's what getItemContent returns
+        // These are all streams but with different content to demonstrate handling different data types from the stream
+        const createMockStream = (content) => ({
+            on: jest.fn().mockImplementation((event, callback) => {
+                if (event === 'data') {
+                    callback(Buffer.from(content));
+                }
+                else if (event === 'end') {
+                    setTimeout(callback, 0);
+                }
+                return createMockStream(content); // Return this for chaining
+            }),
+        });
+        // Create four different mock streams with different content
+        const mockStream1 = createMockStream('Buffer content');
+        const mockStream2 = createMockStream('String content');
+        const mockStream3 = createMockStream(JSON.stringify({ foo: 'bar', baz: 42 }));
+        const mockStream4 = createMockStream('hello');
+        // Mock Git API to return our different mock streams for each repository
+        const mockGitApi = {
+            getItemContent: jest
+                .fn()
+                .mockImplementationOnce(() => Promise.resolve(mockStream1))
+                .mockImplementationOnce(() => Promise.resolve(mockStream2))
+                .mockImplementationOnce(() => Promise.resolve(mockStream3))
+                .mockImplementationOnce(() => Promise.resolve(mockStream4)),
+        };
+        const mockConnectionWithStreams = {
+            ...mockConnection,
+            getGitApi: jest.fn().mockResolvedValue(mockGitApi),
+            serverUrl: 'https://dev.azure.com/testorg',
+        };
+        // Act
+        const result = await searchCode(mockConnectionWithStreams, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            includeContent: true,
+        });
+        // Assert
+        expect(result).toBeDefined();
+        expect(result.count).toBe(4);
+        expect(result.results).toHaveLength(4);
+        // Check each result has appropriate content from the streams
+        // Result 1 - Buffer content stream
+        expect(result.results[0].content).toBe('Buffer content');
+        // Result 2 - String content stream
+        expect(result.results[1].content).toBe('String content');
+        // Result 3 - JSON object content stream
+        expect(result.results[2].content).toBe('{"foo":"bar","baz":42}');
+        // Result 4 - Text content stream
+        expect(result.results[3].content).toBe('hello');
+        // Git API should have been called 4 times
+        expect(mockGitApi.getItemContent).toHaveBeenCalledTimes(4);
+        // Verify the parameters for the first call
+        expect(mockGitApi.getItemContent.mock.calls[0]).toEqual([
+            'repo-id-1',
+            '/src/example1.ts',
+            'TestProject',
+            undefined,
+            undefined,
+            undefined,
+            undefined,
+            false,
+            {
+                version: 'commit-hash-1',
+                versionType: GitVersionType.Commit,
+            },
+            true,
+        ]);
+    });
+    test('should properly convert content stream to string', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 1,
+                results: [
+                    {
+                        fileName: 'example.ts',
+                        path: '/src/example.ts',
+                        matches: {
+                            content: [
+                                {
+                                    charOffset: 17,
+                                    length: 7,
+                                },
+                            ],
+                        },
+                        collection: {
+                            name: 'DefaultCollection',
+                        },
+                        project: {
+                            name: 'TestProject',
+                            id: 'project-id',
+                        },
+                        repository: {
+                            name: 'TestRepo',
+                            id: 'repo-id',
+                            type: 'git',
+                        },
+                        versions: [
+                            {
+                                branchName: 'main',
+                                changeId: 'commit-hash',
+                            },
+                        ],
+                        contentId: 'content-hash',
+                    },
+                ],
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Create a mock ReadableStream
+        const mockContent = 'This is the file content';
+        // Create a simplified mock stream that emits the content
+        const mockStream = {
+            on: jest.fn().mockImplementation((event, callback) => {
+                if (event === 'data') {
+                    // Call the callback with the data
+                    callback(Buffer.from(mockContent));
+                }
+                else if (event === 'end') {
+                    // Call the end callback asynchronously
+                    setTimeout(callback, 0);
+                }
+                return mockStream; // Return this for chaining
+            }),
+        };
+        // Mock Git API to return our mock stream
+        const mockGitApi = {
+            getItemContent: jest.fn().mockResolvedValue(mockStream),
+        };
+        const mockConnectionWithStream = {
+            ...mockConnection,
+            getGitApi: jest.fn().mockResolvedValue(mockGitApi),
+            serverUrl: 'https://dev.azure.com/testorg',
+        };
+        // Act
+        const result = await searchCode(mockConnectionWithStream, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            includeContent: true,
+        });
+        // Assert
+        expect(result).toBeDefined();
+        expect(result.count).toBe(1);
+        expect(result.results).toHaveLength(1);
+        // Check that the content was properly converted from stream to string
+        expect(result.results[0].content).toBe(mockContent);
+        // Verify the stream event handlers were attached
+        expect(mockStream.on).toHaveBeenCalledWith('data', expect.any(Function));
+        expect(mockStream.on).toHaveBeenCalledWith('end', expect.any(Function));
+        expect(mockStream.on).toHaveBeenCalledWith('error', expect.any(Function));
+        // Verify the parameters for getItemContent
+        expect(mockGitApi.getItemContent).toHaveBeenCalledWith('repo-id', '/src/example.ts', 'TestProject', undefined, undefined, undefined, undefined, false, {
+            version: 'commit-hash',
+            versionType: GitVersionType.Commit,
+        }, true);
+    });
+    test('should limit top to 10 when includeContent is true', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 10,
+                results: Array(10)
+                    .fill(0)
+                    .map((_, i) => ({
+                    fileName: `example${i}.ts`,
+                    path: `/src/example${i}.ts`,
+                    matches: {
+                        content: [
+                            {
+                                charOffset: 17,
+                                length: 7,
+                            },
+                        ],
+                    },
+                    collection: {
+                        name: 'DefaultCollection',
+                    },
+                    project: {
+                        name: 'TestProject',
+                        id: 'project-id',
+                    },
+                    repository: {
+                        name: 'TestRepo',
+                        id: 'repo-id',
+                        type: 'git',
+                    },
+                    versions: [
+                        {
+                            branchName: 'main',
+                            changeId: 'commit-hash',
+                        },
+                    ],
+                    contentId: `content-hash-${i}`,
+                })),
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // For this test, we don't need to mock the Git API since we're only testing the top parameter
+        // We'll create a connection that doesn't have includeContent functionality
+        const mockConnectionWithoutContent = {
+            ...mockConnection,
+            getGitApi: jest.fn().mockImplementation(() => {
+                throw new Error('Git API not available');
+            }),
+            serverUrl: 'https://dev.azure.com/testorg',
+        };
+        // Act
+        await searchCode(mockConnectionWithoutContent, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            top: 50, // User tries to get 50 results
+            includeContent: true, // But includeContent is true
+        });
+        // Assert
+        expect(mockedAxios.post).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            $top: 10, // Should be limited to 10
+        }), expect.any(Object));
+    });
+    test('should not limit top when includeContent is false', async () => {
+        // Arrange
+        const mockSearchResponse = {
+            data: {
+                count: 50,
+                results: Array(50)
+                    .fill(0)
+                    .map((_, i) => ({
+                    // ... simplified result object
+                    fileName: `example${i}.ts`,
+                })),
+            },
+        };
+        mockedAxios.post.mockResolvedValueOnce(mockSearchResponse);
+        // Act
+        await searchCode(mockConnection, {
+            searchText: 'example',
+            projectId: 'TestProject',
+            top: 50, // User wants 50 results
+            includeContent: false, // includeContent is false
+        });
+        // Assert
+        expect(mockedAxios.post).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+            $top: 50, // Should use requested value
+        }), expect.any(Object));
+    });
+});
+//# sourceMappingURL=feature.spec.unit.js.map