Added test for fetch for firestore

Author: maneesht

common/api-review/storage.api.md

@@ -58,7 +58,7 @@ export class _FirebaseStorageImpl implements FirebaseStorage {
     constructor(
     app: FirebaseApp, _authProvider: Provider<FirebaseAuthInternalName>,
     _appCheckProvider: Provider<AppCheckInternalComponentName>,
-    _url?: string | undefined, _firebaseVersion?: string | undefined);
+    _url?: string | undefined, _firebaseVersion?: string | undefined, _isUsingEmulator?: boolean);
     readonly app: FirebaseApp;
     // (undocumented)
     readonly _appCheckProvider: Provider<AppCheckInternalComponentName>;
@@ -77,6 +77,8 @@ export class _FirebaseStorageImpl implements FirebaseStorage {
     _getAuthToken(): Promise<string | null>;
     get host(): string;
     set host(host: string);
+    // (undocumented)
+    _isUsingEmulator: boolean;
     // Warning: (ae-forgotten-export) The symbol "ConnectionType" needs to be exported by the entry point index.d.ts
     // Warning: (ae-forgotten-export) The symbol "RequestInfo" needs to be exported by the entry point index.d.ts
     // Warning: (ae-forgotten-export) The symbol "Connection" needs to be exported by the entry point index.d.ts

packages/data-connect/test/unit/fetch.test.ts

@@ -18,10 +18,12 @@
 import { expect, use } from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import * as sinon from 'sinon';
+import sinonChai from 'sinon-chai';
 
 import { dcFetch, initializeFetch } from '../../src/network/fetch';
 import { CallerSdkType, CallerSdkTypeEnum } from '../../src/network/transport';
 use(chaiAsPromised);
+use(sinonChai);
 function mockFetch(json: object, reject: boolean): sinon.SinonStub {
   const fakeFetchImpl = sinon.stub().returns(
     Promise.resolve({

packages/firestore/src/lite-api/components.ts

@@ -110,7 +110,6 @@ export function makeDatabaseInfo(
   persistenceKey: string,
   settings: FirestoreSettingsImpl
 ): DatabaseInfo {
-  const privateSettings = settings as PrivateSettings;
   return new DatabaseInfo(
     databaseId,
     appId,
@@ -121,6 +120,6 @@ export function makeDatabaseInfo(
     settings.experimentalAutoDetectLongPolling,
     cloneLongPollingOptions(settings.experimentalLongPollingOptions),
     settings.useFetchStreams,
-    privateSettings.emulatorOptions !== undefined
+    settings.isUsingEmulator
   );
 }

packages/firestore/src/lite-api/settings.ts

@@ -112,6 +112,8 @@ export class FirestoreSettingsImpl {
   readonly useFetchStreams: boolean;
   readonly localCache?: FirestoreLocalCache;
 
+  readonly isUsingEmulator: boolean;
+
   // Can be a google-auth-library or gapi client.
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   credentials?: any;
@@ -130,6 +132,7 @@ export class FirestoreSettingsImpl {
       this.host = settings.host;
       this.ssl = settings.ssl ?? DEFAULT_SSL;
     }
+    this.isUsingEmulator = settings.emulatorOptions !== undefined;
 
     this.credentials = settings.credentials;
     this.ignoreUndefinedProperties = !!settings.ignoreUndefinedProperties;

packages/firestore/src/platform/browser_lite/fetch_connection.ts

@@ -52,7 +52,7 @@ export class FetchConnection extends RestConnection {
         headers,
         body: requestJson
       };
-      if (isCloudWorkstation(url) && isUsingEmulator) {
+      if (isCloudWorkstation(new URL(url).host) && isUsingEmulator) {
         fetchArgs.credentials = 'include';
       }
       response = await fetch(url, fetchArgs);

packages/firestore/test/unit/remote/fetch_connection.test.ts

@@ -0,0 +1,79 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as sinon from 'sinon';
+import { expect, use } from 'chai';
+import { DatabaseId } from '../../../src/core/database_info';
+import { makeDatabaseInfo } from '../../../src/lite-api/components';
+import {
+  FirestoreSettingsImpl,
+  PrivateSettings
+} from '../../../src/lite-api/settings';
+import { ResourcePath } from '../../../src/model/path';
+import { FetchConnection } from '../../../src/platform/browser_lite/fetch_connection';
+import sinonChai from 'sinon-chai';
+import chaiAsPromised from 'chai-as-promised';
+
+use(sinonChai);
+use(chaiAsPromised);
+
+describe('Fetch Connection', () => {
+  it('should pass in credentials if using emulator and cloud workstation', async () => {
+    const privateSettings: PrivateSettings = {
+      emulatorOptions: {},
+      host: 'abc.cloudworkstations.dev'
+    };
+    console.log(
+      makeDatabaseInfo(
+        DatabaseId.empty(),
+        '',
+        '',
+        new FirestoreSettingsImpl(privateSettings)
+      )
+    );
+    const stub = sinon.stub(globalThis, 'fetch');
+    stub.resolves({
+      ok: true,
+      json() {
+        return Promise.resolve();
+      }
+    } as Response);
+    const fetchConnection = new FetchConnection(
+      makeDatabaseInfo(
+        DatabaseId.empty(),
+        '',
+        '',
+        new FirestoreSettingsImpl({
+          host: 'abc.cloudworkstations.dev',
+          emulatorOptions: {}
+        })
+      )
+    );
+    await fetchConnection.invokeRPC(
+      'Commit',
+      new ResourcePath([]),
+      {},
+      null,
+      null
+    );
+    expect(stub).to.have.been.calledWithMatch(
+      'https://abc.cloudworkstations.dev/v1/:commit',
+      { credentials: 'include' }
+    );
+    stub.restore();
+  });
+});

packages/storage/src/implementation/request.ts

@@ -115,9 +115,9 @@ class NetworkRequest<I extends ConnectionType, O> implements Request<O> {
         .send(
           this.url_,
           this.method_,
+          this.isUsingEmulator,
           this.body_,
-          this.headers_,
-          this.isUsingEmulator
+          this.headers_
         )
         .then(() => {
           if (this.progressCallback_ !== null) {

packages/storage/src/platform/browser/connection.ts

@@ -63,9 +63,9 @@ abstract class XhrConnection<T extends ConnectionType>
   send(
     url: string,
     method: string,
+    isUsingEmulator: boolean,
     body?: ArrayBufferView | Blob | string,
-    headers?: Headers,
-    isUsingEmulator?: boolean
+    headers?: Headers
   ): Promise<void> {
     if (this.sent_) {
       throw internalError('cannot .send() more than once');

packages/storage/test/browser/connection.test.ts

@@ -24,11 +24,27 @@ describe('Connections', () => {
   it('XhrConnection.send() should not reject on network errors', async () => {
     const fakeXHR = useFakeXMLHttpRequest();
     const connection = new XhrBytesConnection();
-    const sendPromise = connection.send('testurl', 'GET');
+    const sendPromise = connection.send('testurl', 'GET', false);
     // simulate a network error
     ((connection as any).xhr_ as SinonFakeXMLHttpRequest).error();
     await sendPromise;
     expect(connection.getErrorCode()).to.equal(ErrorCode.NETWORK_ERROR);
     fakeXHR.restore();
   });
+  it('XhrConnection.send() should send credentials when using cloud workstation', async () => {
+    const fakeXHR = useFakeXMLHttpRequest();
+    const connection = new XhrBytesConnection();
+    const sendPromise = connection.send(
+      'https://abc.cloudworkstations.dev',
+      'GET',
+      true
+    );
+    // simulate a network error
+    ((connection as any).xhr_ as SinonFakeXMLHttpRequest).error();
+    await sendPromise;
+    expect(
+      ((connection as any).xhr_ as SinonFakeXMLHttpRequest).withCredentials
+    ).to.be.true;
+    fakeXHR.restore();
+  });
 });

packages/storage/test/node/connection.test.ts

@@ -27,6 +27,25 @@ describe('Connections', () => {
     const fetchStub = stub(globalThis, 'fetch').rejects();
     await connection.send('testurl', 'GET', false);
     expect(connection.getErrorCode()).to.equal(ErrorCode.NETWORK_ERROR);
+
+    fetchStub.restore();
+  });
+  it('FetchConnection.send() should send credentials on cloud workstations', async () => {
+    const connection = new FetchBytesConnection();
+
+    const fetchStub = stub(globalThis, 'fetch').rejects();
+    await connection.send(
+      'http://something.cloudworkstations.dev',
+      'GET',
+      true
+    );
+    expect(connection.getErrorCode()).to.equal(ErrorCode.NETWORK_ERROR);
+    expect(fetchStub).to.have.been.calledWithMatch(
+      'http://something.cloudworkstations.dev',
+      {
+        credentials: 'include'
+      }
+    );
     fetchStub.restore();
   });
 });