Fix all tests

Author: dlarocque

common/api-review/vertexai.api.md

@@ -28,7 +28,7 @@ export const BackendType: {
 };
 
 // @public (undocumented)
-export type BackendType = typeof BackendType[keyof typeof BackendType];
+export type BackendType = (typeof BackendType)[keyof typeof BackendType];
 
 // @public
 export interface BaseParams {
@@ -901,4 +901,6 @@ export interface WebAttribution {
 }
 
 
+// (No @packageDocumentation comment for this package)
+
 ```

packages/vertexai/.eslintrc.js

@@ -30,6 +30,7 @@ module.exports = {
       {
         'packageDir': [path.resolve(__dirname, '../../'), __dirname]
       }
-    ]
+    ],
+    '@typescript-eslint/consistent-type-definitions': 0
   }
 };

packages/vertexai/src/api.test.ts

@@ -16,12 +16,12 @@
  */
 import { ImagenModelParams, ModelParams, GenAIErrorCode } from './types';
 import { GenAIError } from './errors';
-import { ImagenModel, getGenerativeModel, getImagenModel } from './api';
+import { ImagenModel, getGenerativeModel, getImagenModel, vertexAIBackend } from './api';
 import { expect } from 'chai';
-import { VertexAI } from './public-types';
+import { GenAI } from './public-types';
 import { GenerativeModel } from './models/generative-model';
 
-const fakeVertexAI: VertexAI = {
+const fakeGenAI: GenAI = {
   app: {
     name: 'DEFAULT',
     automaticDataCollectionEnabled: true,
@@ -31,13 +31,14 @@ const fakeVertexAI: VertexAI = {
       appId: 'my-appid'
     }
   },
+  backend: vertexAIBackend('us-central1'),
   location: 'us-central1'
 };
 
 describe('Top level API', () => {
   it('getGenerativeModel throws if no model is provided', () => {
     try {
-      getGenerativeModel(fakeVertexAI, {} as ModelParams);
+      getGenerativeModel(fakeGenAI, {} as ModelParams);
     } catch (e) {
       expect((e as GenAIError).code).includes(GenAIErrorCode.NO_MODEL);
       expect((e as GenAIError).message).includes(
@@ -48,9 +49,9 @@ describe('Top level API', () => {
   });
   it('getGenerativeModel throws if no apiKey is provided', () => {
     const fakeVertexNoApiKey = {
-      ...fakeVertexAI,
+      ...fakeGenAI,
       app: { options: { projectId: 'my-project', appId: 'my-appid' } }
-    } as VertexAI;
+    } as GenAI;
     try {
       getGenerativeModel(fakeVertexNoApiKey, { model: 'my-model' });
     } catch (e) {
@@ -64,15 +65,13 @@ describe('Top level API', () => {
   });
   it('getGenerativeModel throws if no projectId is provided', () => {
     const fakeVertexNoProject = {
-      ...fakeVertexAI,
+      ...fakeGenAI,
       app: { options: { apiKey: 'my-key', appId: 'my-appid' } }
-    } as VertexAI;
+    } as GenAI;
     try {
       getGenerativeModel(fakeVertexNoProject, { model: 'my-model' });
     } catch (e) {
-      expect((e as GenAIError).code).includes(
-        GenAIErrorCode.NO_PROJECT_ID
-      );
+      expect((e as GenAIError).code).includes(GenAIErrorCode.NO_PROJECT_ID);
       expect((e as GenAIError).message).equals(
         `VertexAI: The "projectId" field is empty in the local` +
           ` Firebase config. Firebase VertexAI requires this field ` +
@@ -82,28 +81,28 @@ describe('Top level API', () => {
   });
   it('getGenerativeModel throws if no appId is provided', () => {
     const fakeVertexNoProject = {
-      ...fakeVertexAI,
+      ...fakeGenAI,
       app: { options: { apiKey: 'my-key', projectId: 'my-projectid' } }
-    } as VertexAI;
+    } as GenAI;
     try {
       getGenerativeModel(fakeVertexNoProject, { model: 'my-model' });
     } catch (e) {
-      expect((e as VertexAIError).code).includes(VertexAIErrorCode.NO_APP_ID);
-      expect((e as VertexAIError).message).equals(
+      expect((e as GenAIError).code).includes(GenAIErrorCode.NO_APP_ID);
+      expect((e as GenAIError).message).equals(
         `VertexAI: The "appId" field is empty in the local` +
           ` Firebase config. Firebase VertexAI requires this field ` +
-          `to contain a valid app ID. (vertexAI/${VertexAIErrorCode.NO_APP_ID})`
+          `to contain a valid app ID. (vertexAI/${GenAIErrorCode.NO_APP_ID})`
       );
     }
   });
   it('getGenerativeModel gets a GenerativeModel', () => {
-    const genModel = getGenerativeModel(fakeVertexAI, { model: 'my-model' });
+    const genModel = getGenerativeModel(fakeGenAI, { model: 'my-model' });
     expect(genModel).to.be.an.instanceOf(GenerativeModel);
     expect(genModel.model).to.equal('publishers/google/models/my-model');
   });
   it('getImagenModel throws if no model is provided', () => {
     try {
-      getImagenModel(fakeVertexAI, {} as ImagenModelParams);
+      getImagenModel(fakeGenAI, {} as ImagenModelParams);
     } catch (e) {
       expect((e as GenAIError).code).includes(GenAIErrorCode.NO_MODEL);
       expect((e as GenAIError).message).includes(
@@ -114,9 +113,9 @@ describe('Top level API', () => {
   });
   it('getImagenModel throws if no apiKey is provided', () => {
     const fakeVertexNoApiKey = {
-      ...fakeVertexAI,
+      ...fakeGenAI,
       app: { options: { projectId: 'my-project', appId: 'my-appid' } }
-    } as VertexAI;
+    } as GenAI;
     try {
       getImagenModel(fakeVertexNoApiKey, { model: 'my-model' });
     } catch (e) {
@@ -130,15 +129,13 @@ describe('Top level API', () => {
   });
   it('getImagenModel throws if no projectId is provided', () => {
     const fakeVertexNoProject = {
-      ...fakeVertexAI,
+      ...fakeGenAI,
       app: { options: { apiKey: 'my-key', appId: 'my-appid' } }
-    } as VertexAI;
+    } as GenAI;
     try {
       getImagenModel(fakeVertexNoProject, { model: 'my-model' });
     } catch (e) {
-      expect((e as GenAIError).code).includes(
-        GenAIErrorCode.NO_PROJECT_ID
-      );
+      expect((e as GenAIError).code).includes(GenAIErrorCode.NO_PROJECT_ID);
       expect((e as GenAIError).message).equals(
         `VertexAI: The "projectId" field is empty in the local` +
           ` Firebase config. Firebase VertexAI requires this field ` +
@@ -148,22 +145,22 @@ describe('Top level API', () => {
   });
   it('getImagenModel throws if no appId is provided', () => {
     const fakeVertexNoProject = {
-      ...fakeVertexAI,
+      ...fakeGenAI,
       app: { options: { apiKey: 'my-key', projectId: 'my-project' } }
-    } as VertexAI;
+    } as GenAI;
     try {
       getImagenModel(fakeVertexNoProject, { model: 'my-model' });
     } catch (e) {
-      expect((e as VertexAIError).code).includes(VertexAIErrorCode.NO_APP_ID);
-      expect((e as VertexAIError).message).equals(
+      expect((e as GenAIError).code).includes(GenAIErrorCode.NO_APP_ID);
+      expect((e as GenAIError).message).equals(
         `VertexAI: The "appId" field is empty in the local` +
           ` Firebase config. Firebase VertexAI requires this field ` +
-          `to contain a valid app ID. (vertexAI/${VertexAIErrorCode.NO_APP_ID})`
+          `to contain a valid app ID. (vertexAI/${GenAIErrorCode.NO_APP_ID})`
       );
     }
   });
   it('getImagenModel gets an ImagenModel', () => {
-    const genModel = getImagenModel(fakeVertexAI, { model: 'my-model' });
+    const genModel = getImagenModel(fakeGenAI, { model: 'my-model' });
     expect(genModel).to.be.an.instanceOf(ImagenModel);
     expect(genModel.model).to.equal('publishers/google/models/my-model');
   });

packages/vertexai/src/api.ts

@@ -20,7 +20,15 @@ import { Provider } from '@firebase/component';
 import { getModularInstance } from '@firebase/util';
 import { DEFAULT_LOCATION, GENAI_TYPE } from './constants';
 import { GenAIService } from './service';
-import { BackendType, GenAI, GenAIOptions, GoogleAIBackend, VertexAI, VertexAIBackend, VertexAIOptions } from './public-types';
+import {
+  BackendType,
+  GenAI,
+  GenAIOptions,
+  GoogleAIBackend,
+  VertexAI,
+  VertexAIBackend,
+  VertexAIOptions
+} from './public-types';
 import {
   ImagenModelParams,
   ModelParams,
@@ -38,7 +46,7 @@ export { GenAIModel, GenerativeModel, ImagenModel, GenAIError };
 
 // Temporary aliases from new 'GenAI' names to the original 'VertexAI' names.
 // These will be removed in v12 of the SDK.
-export { 
+export {
   GenAIModel as VertexAIModel,
   GenAIError as VertexAIError,
   GenAIErrorCode as VertexAIErrorCode
@@ -54,7 +62,7 @@ declare module '@firebase/component' {
  * Returns a <code>{@link VertexAI}</code> instance for the given app.
  *
  * @public
- * 
+ *
  * @param app - The {@link @firebase/app#FirebaseApp} to use.
  */
 export function getVertexAI(
@@ -67,15 +75,15 @@ export function getVertexAI(
 
   const identifier = encodeInstanceIdentifier({
     backendType: BackendType.VERTEX_AI,
-    location: options?.location ?? ""
+    location: options?.location ?? ''
   });
   return genAIProvider.getImmediate({
     identifier
   });
 }
 
 /**
- * Returns a <code>{@link VertexAI}</code> instance for the given app that has the Developer
+ * Returns a <code>{@link GenAI}</code> instance for the given app that has the Developer
  * API enabled.
  *
  * @public
@@ -90,9 +98,7 @@ export function getGenAI(
   // Dependencies
   const genAIProvider: Provider<'genAI'> = _getProvider(app, GENAI_TYPE);
 
-  const identifier = encodeInstanceIdentifier(
-    options.backend
-  );
+  const identifier = encodeInstanceIdentifier(options.backend);
   return genAIProvider.getImmediate({
     identifier
   });
@@ -111,7 +117,7 @@ export function vertexAIBackend(location?: string): VertexAIBackend {
     backendType: BackendType.VERTEX_AI,
     location: location ?? DEFAULT_LOCATION
   };
-  
+
   return backend;
 }
 

packages/vertexai/src/constants.ts

@@ -23,8 +23,8 @@ export const VERTEX_TYPE = 'vertexAI';
 export const GENAI_TYPE = 'genAI';
 
 export const DEFAULT_INSTANCE_IDENTIFER: InstanceIdentifier = {
-  backendType: BackendType.GOOGLE_AI,
-}
+  backendType: BackendType.GOOGLE_AI
+};
 
 export const DEFAULT_LOCATION = 'us-central1';
 

packages/vertexai/src/developerAPI.ts

@@ -110,7 +110,6 @@ export function mapGenerateContentResponse(
  */
 export function mapCountTokensRequest(
   countTokensRequest: CountTokensRequest,
-  model: string
 ): DeveloperAPICountTokensRequest {
   const mappedCountTokensRequest: DeveloperAPICountTokensRequest = {
     generateContentRequest: {

packages/vertexai/src/errors.ts

@@ -21,7 +21,7 @@ import { VERTEX_TYPE } from './constants';
 
 /**
  * Error class for the Vertex AI in Firebase SDK.
- * 
+ *
  * @public
  */
 export class GenAIError extends FirebaseError {
@@ -63,4 +63,4 @@ export class GenAIError extends FirebaseError {
     // Since Error is an interface, we don't inherit toString and so we define it ourselves.
     this.toString = () => fullMessage;
   }
-}
+}

packages/vertexai/src/helpers.ts

@@ -24,22 +24,27 @@ import { GenAIErrorCode } from './types';
  * @internal
  */
 export function encodeInstanceIdentifier(
-  instanceIdentifier: InstanceIdentifier,
+  instanceIdentifier: InstanceIdentifier
 ): string {
-  switch(instanceIdentifier.backendType) {
+  switch (instanceIdentifier.backendType) {
     case BackendType.VERTEX_AI:
       return `genai/vertexai/${location || DEFAULT_LOCATION}`;
     case BackendType.GOOGLE_AI:
-      return 'genai/googleai'
+      return 'genai/googleai';
     default:
-      throw new GenAIError(GenAIErrorCode.ERROR, `An internal error occured: Unknown Backend ${instanceIdentifier}. Please submit an issue at https://github.com/firebase/firebase-js-sdk.`)
+      throw new GenAIError(
+        GenAIErrorCode.ERROR,
+        `An internal error occured: Unknown Backend ${instanceIdentifier}. Please submit an issue at https://github.com/firebase/firebase-js-sdk.`
+      );
   }
 }
 
 /**
  * @internal
  */
-export function decodeInstanceIdentifier(instanceIdentifier: string): InstanceIdentifier {
+export function decodeInstanceIdentifier(
+  instanceIdentifier: string
+): InstanceIdentifier {
   const identifierParts = instanceIdentifier.split('/');
   const backend = identifierParts[1];
   switch (backend) {
@@ -51,7 +56,7 @@ export function decodeInstanceIdentifier(instanceIdentifier: string): InstanceId
       };
     case 'googleai':
       return {
-        backendType: BackendType.GOOGLE_AI,
+        backendType: BackendType.GOOGLE_AI
       };
     default:
       throw new GenAIError(

packages/vertexai/src/index.node.ts

@@ -41,19 +41,16 @@ function registerGenAI(): void {
 
         let instanceIdentifier: InstanceIdentifier;
         if (options.instanceIdentifier) {
-          instanceIdentifier = decodeInstanceIdentifier(options.instanceIdentifier);
+          instanceIdentifier = decodeInstanceIdentifier(
+            options.instanceIdentifier
+          );
         } else {
           instanceIdentifier = DEFAULT_INSTANCE_IDENTIFER;
         }
 
         const backend = instanceIdentifier;
 
-        return new GenAIService(
-          app,
-          backend,
-          auth,
-          appCheckProvider,
-        );
+        return new GenAIService(app, backend, auth, appCheckProvider);
       },
       ComponentType.PUBLIC
     ).setMultipleInstances(true)