Download packages/core/src/code_assist/setup.test.ts from SaylorTwift/gemini-cli: direct link, hf CLI and curl.
- Browser
- Download file 13.3 kB
-
https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/core/src/code_assist/setup.test.ts
- Command line
-
hf download hf://SaylorTwift/gemini-cli/packages/core/src/code_assist/setup.test.ts
-
curl -L -o setup.test.ts https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/core/src/code_assist/setup.test.ts
13.3 kB
| /** | |
| * @license | |
| * Copyright 2025 Google LLC | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'; | |
| import { | |
| ProjectIdRequiredError, | |
| setupUser, | |
| ValidationCancelledError, | |
| InvalidNumericProjectIdError, | |
| resetUserDataCacheForTesting, | |
| } from './setup.js'; | |
| import { ValidationRequiredError } from '../utils/googleQuotaErrors.js'; | |
| import { CodeAssistServer } from '../code_assist/server.js'; | |
| import type { OAuth2Client } from 'google-auth-library'; | |
| import { UserTierId, type GeminiUserTier } from './types.js'; | |
| import type { Config } from '../config/config.js'; | |
| import { | |
| logOnboardingSuccess, | |
| OnboardingSuccessEvent, | |
| } from '../telemetry/index.js'; | |
| vi.mock('../code_assist/server.js'); | |
| vi.mock('../telemetry/index.js', async (importOriginal) => { | |
| const actual = await importOriginal<typeof import('../telemetry/index.js')>(); | |
| return { | |
| ...actual, | |
| logOnboardingStart: vi.fn(), | |
| logOnboardingSuccess: vi.fn(), | |
| }; | |
| }); | |
| const mockPaidTier: GeminiUserTier = { | |
| id: UserTierId.STANDARD, | |
| name: 'paid', | |
| description: 'Paid tier', | |
| isDefault: true, | |
| }; | |
| const mockFreeTier: GeminiUserTier = { | |
| id: UserTierId.FREE, | |
| name: 'free', | |
| description: 'Free tier', | |
| isDefault: true, | |
| }; | |
| describe('setupUser', () => { | |
| let mockLoad: ReturnType<typeof vi.fn>; | |
| let mockOnboardUser: ReturnType<typeof vi.fn>; | |
| let mockGetOperation: ReturnType<typeof vi.fn>; | |
| let mockConfig: Config; | |
| let mockValidationHandler: ReturnType<typeof vi.fn>; | |
| beforeEach(() => { | |
| vi.resetAllMocks(); | |
| resetUserDataCacheForTesting(); | |
| vi.useFakeTimers(); | |
| mockLoad = vi.fn(); | |
| mockOnboardUser = vi.fn().mockResolvedValue({ | |
| done: true, | |
| response: { | |
| cloudaicompanionProject: { | |
| id: 'server-project', | |
| }, | |
| }, | |
| }); | |
| mockGetOperation = vi.fn(); | |
| vi.mocked(CodeAssistServer).mockImplementation( | |
| () => | |
| ({ | |
| loadCodeAssist: mockLoad, | |
| onboardUser: mockOnboardUser, | |
| getOperation: mockGetOperation, | |
| }) as unknown as CodeAssistServer, | |
| ); | |
| mockValidationHandler = vi.fn(); | |
| mockConfig = { | |
| getValidationHandler: () => mockValidationHandler, | |
| getUsageStatisticsEnabled: () => true, | |
| getSessionId: () => 'test-session-id', | |
| getContentGeneratorConfig: () => ({ | |
| authType: 'google-login', | |
| }), | |
| isInteractive: () => false, | |
| getExperiments: () => undefined, | |
| } as unknown as Config; | |
| }); | |
| afterEach(() => { | |
| vi.useRealTimers(); | |
| vi.unstubAllEnvs(); | |
| }); | |
| describe('caching', () => { | |
| it('should cache setup result for same client and projectId', async () => { | |
| mockLoad.mockResolvedValue({ | |
| currentTier: mockPaidTier, | |
| cloudaicompanionProject: 'server-project', | |
| }); | |
| const client = {} as OAuth2Client; | |
| // First call | |
| await setupUser(client, mockConfig); | |
| // Second call | |
| await setupUser(client, mockConfig); | |
| expect(mockLoad).toHaveBeenCalledTimes(1); | |
| }); | |
| it('should re-fetch if projectId changes', async () => { | |
| mockLoad.mockResolvedValue({ | |
| currentTier: mockPaidTier, | |
| cloudaicompanionProject: 'server-project', | |
| }); | |
| const client = {} as OAuth2Client; | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'p1'); | |
| await setupUser(client, mockConfig); | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'p2'); | |
| await setupUser(client, mockConfig); | |
| expect(mockLoad).toHaveBeenCalledTimes(2); | |
| }); | |
| it('should re-fetch if cache expires', async () => { | |
| mockLoad.mockResolvedValue({ | |
| currentTier: mockPaidTier, | |
| cloudaicompanionProject: 'server-project', | |
| }); | |
| const client = {} as OAuth2Client; | |
| await setupUser(client, mockConfig); | |
| vi.advanceTimersByTime(31000); // 31s > 30s expiration | |
| await setupUser(client, mockConfig); | |
| expect(mockLoad).toHaveBeenCalledTimes(2); | |
| }); | |
| it('should retry if previous attempt failed', async () => { | |
| mockLoad.mockRejectedValueOnce(new Error('Network error')); | |
| mockLoad.mockResolvedValueOnce({ | |
| currentTier: mockPaidTier, | |
| cloudaicompanionProject: 'server-project', | |
| }); | |
| const client = {} as OAuth2Client; | |
| await expect(setupUser(client, mockConfig)).rejects.toThrow( | |
| 'Network error', | |
| ); | |
| await setupUser(client, mockConfig); | |
| expect(mockLoad).toHaveBeenCalledTimes(2); | |
| }); | |
| }); | |
| describe('existing user', () => { | |
| it('should use GOOGLE_CLOUD_PROJECT when set and project from server is undefined', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project'); | |
| mockLoad.mockResolvedValue({ | |
| currentTier: mockPaidTier, | |
| }); | |
| await setupUser({} as OAuth2Client, mockConfig); | |
| expect(CodeAssistServer).toHaveBeenCalledWith( | |
| {}, | |
| 'test-project', | |
| {}, | |
| '', | |
| undefined, | |
| undefined, | |
| ); | |
| }); | |
| it('should pass httpOptions to CodeAssistServer when provided', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project'); | |
| mockLoad.mockResolvedValue({ | |
| currentTier: mockPaidTier, | |
| }); | |
| const httpOptions = { | |
| headers: { | |
| 'User-Agent': 'GeminiCLI/1.0.0/gemini-2.0-flash (darwin; arm64)', | |
| }, | |
| }; | |
| await setupUser({} as OAuth2Client, mockConfig, httpOptions); | |
| expect(CodeAssistServer).toHaveBeenCalledWith( | |
| {}, | |
| 'test-project', | |
| httpOptions, | |
| '', | |
| undefined, | |
| undefined, | |
| ); | |
| }); | |
| it('should ignore GOOGLE_CLOUD_PROJECT when project from server is set', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project'); | |
| mockLoad.mockResolvedValue({ | |
| cloudaicompanionProject: 'server-project', | |
| currentTier: mockPaidTier, | |
| }); | |
| const result = await setupUser({} as OAuth2Client, mockConfig); | |
| expect(result.projectId).toBe('server-project'); | |
| }); | |
| it('should throw ProjectIdRequiredError when no project ID is available', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', ''); | |
| // And the server itself requires a project ID internally | |
| vi.mocked(CodeAssistServer).mockImplementation(() => { | |
| throw new ProjectIdRequiredError(); | |
| }); | |
| await expect(setupUser({} as OAuth2Client, mockConfig)).rejects.toThrow( | |
| ProjectIdRequiredError, | |
| ); | |
| }); | |
| it('should throw InvalidNumericProjectIdError when GOOGLE_CLOUD_PROJECT is numeric', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', '1234567890'); | |
| await expect(setupUser({} as OAuth2Client, mockConfig)).rejects.toThrow( | |
| InvalidNumericProjectIdError, | |
| ); | |
| }); | |
| it('should throw InvalidNumericProjectIdError when GOOGLE_CLOUD_PROJECT_ID is numeric', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', ''); | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT_ID', '1234567890'); | |
| await expect(setupUser({} as OAuth2Client, mockConfig)).rejects.toThrow( | |
| InvalidNumericProjectIdError, | |
| ); | |
| }); | |
| }); | |
| describe('new user', () => { | |
| it('should onboard a new paid user with GOOGLE_CLOUD_PROJECT', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project'); | |
| mockLoad.mockResolvedValue({ | |
| allowedTiers: [mockPaidTier], | |
| }); | |
| mockOnboardUser.mockImplementation(async () => { | |
| await new Promise((resolve) => setTimeout(resolve, 1500)); | |
| return { | |
| done: true, | |
| response: { | |
| cloudaicompanionProject: { | |
| id: 'server-project', | |
| }, | |
| }, | |
| }; | |
| }); | |
| const userDataPromise = setupUser({} as OAuth2Client, mockConfig); | |
| await vi.advanceTimersByTimeAsync(1500); | |
| const userData = await userDataPromise; | |
| expect(mockOnboardUser).toHaveBeenCalledWith( | |
| expect.objectContaining({ | |
| tierId: UserTierId.STANDARD, | |
| cloudaicompanionProject: 'test-project', | |
| }), | |
| ); | |
| expect(userData).toEqual({ | |
| projectId: 'server-project', | |
| userTier: UserTierId.STANDARD, | |
| userTierName: 'paid', | |
| hasOnboardedPreviously: false, | |
| }); | |
| expect(logOnboardingSuccess).toHaveBeenCalledWith( | |
| mockConfig, | |
| expect.any(OnboardingSuccessEvent), | |
| ); | |
| const event = vi.mocked(logOnboardingSuccess).mock.calls[0][1]; | |
| expect(event.userTier).toBe('paid'); | |
| expect(event.duration_ms).toBeGreaterThanOrEqual(1500); | |
| }); | |
| it('should onboard a new free user when project ID is not set', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', ''); | |
| mockLoad.mockResolvedValue({ | |
| allowedTiers: [mockFreeTier], | |
| }); | |
| const userData = await setupUser({} as OAuth2Client, mockConfig); | |
| expect(mockOnboardUser).toHaveBeenCalledWith( | |
| expect.objectContaining({ | |
| tierId: UserTierId.FREE, | |
| cloudaicompanionProject: undefined, | |
| }), | |
| ); | |
| expect(userData).toEqual({ | |
| projectId: 'server-project', | |
| userTier: UserTierId.FREE, | |
| userTierName: 'free', | |
| hasOnboardedPreviously: false, | |
| }); | |
| }); | |
| it('should use GOOGLE_CLOUD_PROJECT when onboard response has no project ID', async () => { | |
| vi.stubEnv('GOOGLE_CLOUD_PROJECT', 'test-project'); | |
| mockLoad.mockResolvedValue({ | |
| allowedTiers: [mockPaidTier], | |
| }); | |
| mockOnboardUser.mockResolvedValue({ | |
| done: true, | |
| response: { | |
| cloudaicompanionProject: undefined, | |
| }, | |
| }); | |
| const userData = await setupUser({} as OAuth2Client, mockConfig); | |
| expect(userData).toEqual({ | |
| projectId: 'test-project', | |
| userTier: UserTierId.STANDARD, | |
| userTierName: 'paid', | |
| hasOnboardedPreviously: false, | |
| }); | |
| }); | |
| it('should poll getOperation when onboardUser returns done=false', async () => { | |
| mockLoad.mockResolvedValue({ | |
| allowedTiers: [mockPaidTier], | |
| }); | |
| const operationName = 'operations/123'; | |
| mockOnboardUser.mockResolvedValueOnce({ | |
| name: operationName, | |
| done: false, | |
| }); | |
| mockGetOperation | |
| .mockResolvedValueOnce({ | |
| name: operationName, | |
| done: false, | |
| }) | |
| .mockResolvedValueOnce({ | |
| name: operationName, | |
| done: true, | |
| response: { | |
| cloudaicompanionProject: { | |
| id: 'server-project', | |
| }, | |
| }, | |
| }); | |
| const promise = setupUser({} as OAuth2Client, mockConfig); | |
| await vi.advanceTimersByTimeAsync(5000); | |
| await vi.advanceTimersByTimeAsync(5000); | |
| const userData = await promise; | |
| expect(mockGetOperation).toHaveBeenCalledWith(operationName); | |
| expect(userData.projectId).toBe('server-project'); | |
| }); | |
| }); | |
| describe('validation and errors', () => { | |
| it('should retry if validation handler returns verify', async () => { | |
| mockLoad | |
| .mockResolvedValueOnce({ | |
| currentTier: null, | |
| ineligibleTiers: [ | |
| { | |
| reasonMessage: 'Verify please', | |
| reasonCode: 'VALIDATION_REQUIRED', | |
| tierId: UserTierId.STANDARD, | |
| tierName: 'standard', | |
| validationUrl: 'https://verify', | |
| }, | |
| ], | |
| }) | |
| .mockResolvedValueOnce({ | |
| currentTier: mockPaidTier, | |
| cloudaicompanionProject: 'p1', | |
| }); | |
| mockValidationHandler.mockResolvedValue('verify'); | |
| const result = await setupUser({} as OAuth2Client, mockConfig); | |
| expect(mockValidationHandler).toHaveBeenCalledWith( | |
| 'https://verify', | |
| 'Verify please', | |
| ); | |
| expect(mockLoad).toHaveBeenCalledTimes(2); | |
| expect(result.projectId).toBe('p1'); | |
| }); | |
| it('should throw ValidationCancelledError if handler returns cancel', async () => { | |
| mockLoad.mockResolvedValue({ | |
| currentTier: null, | |
| ineligibleTiers: [ | |
| { | |
| reasonMessage: 'User is not eligible', | |
| reasonCode: 'VALIDATION_REQUIRED', | |
| tierId: UserTierId.STANDARD, | |
| tierName: 'standard', | |
| validationUrl: 'https://example.com/verify', | |
| }, | |
| ], | |
| }); | |
| mockValidationHandler.mockResolvedValue('cancel'); | |
| await expect(setupUser({} as OAuth2Client, mockConfig)).rejects.toThrow( | |
| ValidationCancelledError, | |
| ); | |
| }); | |
| it('should throw error if LoadCodeAssist returns empty response', async () => { | |
| mockLoad.mockResolvedValue(null); | |
| await expect(setupUser({} as OAuth2Client, mockConfig)).rejects.toThrow( | |
| 'LoadCodeAssist returned empty response', | |
| ); | |
| }); | |
| }); | |
| }); | |
| describe('ValidationRequiredError', () => { | |
| const error = new ValidationRequiredError( | |
| 'Account validation required: Please verify', | |
| undefined, | |
| 'https://example.com/verify', | |
| 'Please verify', | |
| ); | |
| it('should be an instance of Error', () => { | |
| expect(error).toBeInstanceOf(Error); | |
| expect(error).toBeInstanceOf(ValidationRequiredError); | |
| }); | |
| it('should have the correct properties', () => { | |
| expect(error.validationLink).toBe('https://example.com/verify'); | |
| expect(error.validationDescription).toBe('Please verify'); | |
| }); | |
| }); | |