time to test

Author: schmidt-sebastian

packages/firestore/src/api.ts

@@ -133,6 +133,8 @@ export { FirestoreErrorCode, FirestoreError } from './util/error';
 
 export { AbstractUserDataWriter } from './lite-api/user_data_writer';
 
+export { FirestoreSettings as Settings } from './lite-api/settings';
+
 export {
   Primitive,
   NestedUpdateFields,

packages/firestore/src/api/snapshot.ts

@@ -59,12 +59,12 @@ import { SnapshotListenOptions } from './reference_impl';
  * }
  *
  * const postConverter = {
- *   toFirestore(post: WithFieldValue<Post>): firebase.firestore.DocumentData {
+ *   toFirestore(post: WithFieldValue<Post>): DocumentData {
  *     return {title: post.title, author: post.author};
  *   },
  *   fromFirestore(
- *     snapshot: firebase.firestore.QueryDocumentSnapshot,
- *     options: firebase.firestore.SnapshotOptions
+ *     snapshot: QueryDocumentSnapshot,
+ *     options: SnapshotOptions
  *   ): Post {
  *     const data = snapshot.data(options)!;
  *     return new Post(data.title, data.author);
@@ -269,7 +269,7 @@ export class DocumentSnapshot<
    * Retrieves all fields in the document as an `Object`. Returns `undefined` if
    * the document doesn't exist.
    *
-   * By default, `FieldValue.serverTimestamp()` values that have not yet been
+   * By default, `serverTimestamp()` values that have not yet been
    * set to their final value will be returned as `null`. You can override
    * this by passing an options object.
    *
@@ -306,7 +306,7 @@ export class DocumentSnapshot<
    * Retrieves the field specified by `fieldPath`. Returns `undefined` if the
    * document or field doesn't exist.
    *
-   * By default, a `FieldValue.serverTimestamp()` that has not yet been set to
+   * By default, a `serverTimestamp()` that has not yet been set to
    * its final value will be returned as `null`. You can override this by
    * passing an options object.
    *
@@ -353,7 +353,7 @@ export class QueryDocumentSnapshot<
   /**
    * Retrieves all fields in the document as an `Object`.
    *
-   * By default, `FieldValue.serverTimestamp()` values that have not yet been
+   * By default, `serverTimestamp()` values that have not yet been
    * set to their final value will be returned as `null`. You can override
    * this by passing an options object.
    *

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

@@ -480,8 +480,7 @@ export function newQueryFilter(
     if (op === Operator.ARRAY_CONTAINS || op === Operator.ARRAY_CONTAINS_ANY) {
       throw new FirestoreError(
         Code.INVALID_ARGUMENT,
-        `Invalid Query. You can't perform '${op}' ` +
-          'queries on FieldPath.documentId().'
+        `Invalid Query. You can't perform '${op}' ` + 'queries on documentId().'
       );
     } else if (op === Operator.IN || op === Operator.NOT_IN) {
       validateDisjunctiveFilterElements(value, op);
@@ -639,7 +638,7 @@ export function newQueryBoundFromFields(
       if (!isCollectionGroupQuery(query) && rawValue.indexOf('/') !== -1) {
         throw new FirestoreError(
           Code.INVALID_ARGUMENT,
-          `Invalid query. When querying a collection and ordering by FieldPath.documentId(), ` +
+          `Invalid query. When querying a collection and ordering by documentId(), ` +
             `the value passed to ${methodName}() must be a plain document ID, but ` +
             `'${rawValue}' contains a slash.`
         );
@@ -649,7 +648,7 @@ export function newQueryBoundFromFields(
         throw new FirestoreError(
           Code.INVALID_ARGUMENT,
           `Invalid query. When querying a collection group and ordering by ` +
-            `FieldPath.documentId(), the value passed to ${methodName}() must result in a ` +
+            `documentId(), the value passed to ${methodName}() must result in a ` +
             `valid document path, but '${path}' is not because it contains an odd number ` +
             `of segments.`
         );
@@ -681,15 +680,15 @@ function parseDocumentIdValue(
     if (documentIdValue === '') {
       throw new FirestoreError(
         Code.INVALID_ARGUMENT,
-        'Invalid query. When querying with FieldPath.documentId(), you ' +
+        'Invalid query. When querying with documentId(), you ' +
           'must provide a valid document ID, but it was an empty string.'
       );
     }
     if (!isCollectionGroupQuery(query) && documentIdValue.indexOf('/') !== -1) {
       throw new FirestoreError(
         Code.INVALID_ARGUMENT,
         `Invalid query. When querying a collection by ` +
-          `FieldPath.documentId(), you must provide a plain document ID, but ` +
+          `documentId(), you must provide a plain document ID, but ` +
           `'${documentIdValue}' contains a '/' character.`
       );
     }
@@ -698,7 +697,7 @@ function parseDocumentIdValue(
       throw new FirestoreError(
         Code.INVALID_ARGUMENT,
         `Invalid query. When querying a collection group by ` +
-          `FieldPath.documentId(), the value provided must result in a valid document path, ` +
+          `documentId(), the value provided must result in a valid document path, ` +
           `but '${path}' is not because it has an odd number of segments (${path.length}).`
       );
     }
@@ -708,7 +707,7 @@ function parseDocumentIdValue(
   } else {
     throw new FirestoreError(
       Code.INVALID_ARGUMENT,
-      `Invalid query. When querying with FieldPath.documentId(), you must provide a valid ` +
+      `Invalid query. When querying with documentId(), you must provide a valid ` +
         `string or a DocumentReference, but it was: ` +
         `${valueDescription(documentIdValue)}.`
     );

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

@@ -57,10 +57,10 @@ import { AbstractUserDataWriter } from './user_data_writer';
  * }
  *
  * const postConverter = {
- *   toFirestore(post: WithFieldValue<Post>): firebase.firestore.DocumentData {
+ *   toFirestore(post: WithFieldValue<Post>): DocumentData {
  *     return {title: post.title, author: post.author};
  *   },
- *   fromFirestore(snapshot: firebase.firestore.QueryDocumentSnapshot): Post {
+ *   fromFirestore(snapshot: QueryDocumentSnapshot): Post {
  *     const data = snapshot.data(options)!;
  *     return new Post(data.title, data.author);
  *   }

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

@@ -722,7 +722,7 @@ export function parseData(
     validatePlainObject('Unsupported field value:', context, input);
     return parseObject(input, context);
   } else if (input instanceof FieldValue) {
-    // FieldValues usually parse into transforms (except FieldValue.delete())
+    // FieldValues usually parse into transforms (except deleteField())
     // in which case we do not want to include this field in our parsed data
     // (as doing so will overwrite the field directly prior to the transform
     // trying to transform it). So we don't add this location to

packages/firestore/test/integration/api/array_transforms.test.ts

@@ -15,18 +15,26 @@
  * limitations under the License.
  */
 
-import * as firestore from '@firebase/firestore-types';
 import { expect } from 'chai';
 
 import { addEqualityMatcher } from '../../util/equality_matcher';
 import { EventsAccumulator } from '../util/events_accumulator';
-import * as firebaseExport from '../util/firebase_export';
+import {
+  doc,
+  DocumentData,
+  DocumentReference,
+  DocumentSnapshot,
+  getDocFromCache,
+  onSnapshot,
+  setDoc,
+  updateDoc,
+  arrayRemove,
+  arrayUnion
+} from '../util/firebase_export';
 import { apiDescribe, withTestDb, withTestDoc } from '../util/helpers';
 
 addEqualityMatcher();
 
-const FieldValue = firebaseExport.FieldValue;
-
 /**
  * Note: Transforms are tested pretty thoroughly in server_timestamp.test.ts
  * (via set, update, transactions, nested in documents, multiple transforms
@@ -35,27 +43,25 @@ const FieldValue = firebaseExport.FieldValue;
  */
 apiDescribe('Array Transforms:', (persistence: boolean) => {
   // A document reference to read and write to.
-  let docRef: firestore.DocumentReference;
+  let docRef: DocumentReference;
 
   // Accumulator used to capture events during the test.
-  let accumulator: EventsAccumulator<firestore.DocumentSnapshot>;
+  let accumulator: EventsAccumulator<DocumentSnapshot>;
 
   // Listener registration for a listener maintained during the course of the
   // test.
   let unsubscribe: () => void;
 
   /** Writes some initialData and consumes the events generated. */
-  async function writeInitialData(
-    initialData: firestore.DocumentData
-  ): Promise<void> {
-    await docRef.set(initialData);
+  async function writeInitialData(initialData: DocumentData): Promise<void> {
+    await setDoc(docRef, initialData);
     await accumulator.awaitLocalEvent();
     const snapshot = await accumulator.awaitRemoteEvent();
     expect(snapshot.data()).to.deep.equal(initialData);
   }
 
   async function expectLocalAndRemoteEvent(
-    expected: firestore.DocumentData
+    expected: DocumentData
   ): Promise<void> {
     const localSnap = await accumulator.awaitLocalEvent();
     expect(localSnap.data()).to.deep.equal(expected);
@@ -70,8 +76,9 @@ apiDescribe('Array Transforms:', (persistence: boolean) => {
   async function withTestSetup<T>(test: () => Promise<T>): Promise<void> {
     await withTestDoc(persistence, async doc => {
       docRef = doc;
-      accumulator = new EventsAccumulator<firestore.DocumentSnapshot>();
-      unsubscribe = docRef.onSnapshot(
+      accumulator = new EventsAccumulator<DocumentSnapshot>();
+      unsubscribe = onSnapshot(
+        docRef,
         { includeMetadataChanges: true },
         accumulator.storeEvent
       );
@@ -86,35 +93,32 @@ apiDescribe('Array Transforms:', (persistence: boolean) => {
 
   it('create document with arrayUnion()', async () => {
     await withTestSetup(async () => {
-      await docRef.set({ array: FieldValue.arrayUnion(1, 2) });
+      await setDoc(docRef, { array: arrayUnion(1, 2) });
       await expectLocalAndRemoteEvent({ array: [1, 2] });
     });
   });
 
   it('append to array via update()', async () => {
     await withTestSetup(async () => {
       await writeInitialData({ array: [1, 3] });
-      await docRef.update({ array: FieldValue.arrayUnion(2, 1, 4) });
+      await updateDoc(docRef, { array: arrayUnion(2, 1, 4) });
       await expectLocalAndRemoteEvent({ array: [1, 3, 2, 4] });
     });
   });
 
   it('append to array via set(..., {merge: true})', async () => {
     await withTestSetup(async () => {
       await writeInitialData({ array: [1, 3] });
-      await docRef.set(
-        { array: FieldValue.arrayUnion(2, 1, 4) },
-        { merge: true }
-      );
+      await setDoc(docRef, { array: arrayUnion(2, 1, 4) }, { merge: true });
       await expectLocalAndRemoteEvent({ array: [1, 3, 2, 4] });
     });
   });
 
   it('append object to array via update()', async () => {
     await withTestSetup(async () => {
       await writeInitialData({ array: [{ a: 'hi' }] });
-      await docRef.update({
-        array: FieldValue.arrayUnion({ a: 'hi' }, { a: 'bye' })
+      await updateDoc(docRef, {
+        array: arrayUnion({ a: 'hi' }, { a: 'bye' })
       });
       await expectLocalAndRemoteEvent({ array: [{ a: 'hi' }, { a: 'bye' }] });
     });
@@ -123,33 +127,30 @@ apiDescribe('Array Transforms:', (persistence: boolean) => {
   it('remove from array via update()', async () => {
     await withTestSetup(async () => {
       await writeInitialData({ array: [1, 3, 1, 3] });
-      await docRef.update({ array: FieldValue.arrayRemove(1, 4) });
+      await updateDoc(docRef, { array: arrayRemove(1, 4) });
       await expectLocalAndRemoteEvent({ array: [3, 3] });
     });
   });
 
   it('remove from array via set(..., {merge: true})', async () => {
     await withTestSetup(async () => {
       await writeInitialData({ array: [1, 3, 1, 3] });
-      await docRef.set(
-        { array: FieldValue.arrayRemove(1, 4) },
-        { merge: true }
-      );
+      await setDoc(docRef, { array: arrayRemove(1, 4) }, { merge: true });
       await expectLocalAndRemoteEvent({ array: [3, 3] });
     });
   });
 
   it('remove object from array via update()', async () => {
     await withTestSetup(async () => {
       await writeInitialData({ array: [{ a: 'hi' }, { a: 'bye' }] });
-      await docRef.update({ array: FieldValue.arrayRemove({ a: 'hi' }) });
+      await updateDoc(docRef, { array: arrayRemove({ a: 'hi' }) });
       await expectLocalAndRemoteEvent({ array: [{ a: 'bye' }] });
     });
   });
 
   it('arrayUnion() supports DocumentReference', async () => {
     await withTestSetup(async () => {
-      await docRef.set({ array: FieldValue.arrayUnion(docRef) });
+      await setDoc(docRef, { array: arrayUnion(docRef) });
       await expectLocalAndRemoteEvent({ array: [docRef] });
     });
   });
@@ -165,8 +166,8 @@ apiDescribe('Array Transforms:', (persistence: boolean) => {
   (persistence ? describe : describe.skip)('Server Application: ', () => {
     it('set() with no cached base doc', async () => {
       await withTestDoc(persistence, async docRef => {
-        await docRef.set({ array: FieldValue.arrayUnion(1, 2) });
-        const snapshot = await docRef.get({ source: 'cache' });
+        await setDoc(docRef, { array: arrayUnion(1, 2) });
+        const snapshot = await getDocFromCache(docRef);
         expect(snapshot.data()).to.deep.equal({ array: [1, 2] });
       });
     });
@@ -177,18 +178,18 @@ apiDescribe('Array Transforms:', (persistence: boolean) => {
       // stored in our cache
       await withTestDoc(persistence, async docRef => {
         path = docRef.path;
-        await docRef.set({ array: [42] });
+        await setDoc(docRef, { array: [42] });
       });
 
       await withTestDb(persistence, async db => {
-        const docRef = db.doc(path!);
-        await docRef.update({ array: FieldValue.arrayUnion(1, 2) });
+        const docRef = doc(db, path!);
+        await updateDoc(docRef, { array: arrayUnion(1, 2) });
 
         // Nothing should be cached since it was an update and we had no base
         // doc.
         let errCaught = false;
         try {
-          await docRef.get({ source: 'cache' });
+          await getDocFromCache(docRef);
         } catch (err) {
           expect(err.code).to.equal('unavailable');
           errCaught = true;
@@ -203,36 +204,33 @@ apiDescribe('Array Transforms:', (persistence: boolean) => {
       // stored in our cache
       await withTestDoc(persistence, async docRef => {
         path = docRef.path;
-        await docRef.set({ array: [42] });
+        await setDoc(docRef, { array: [42] });
       });
 
       await withTestDb(persistence, async db => {
-        const docRef = db.doc(path!);
-        await docRef.set(
-          { array: FieldValue.arrayUnion(1, 2) },
-          { merge: true }
-        );
+        const docRef = doc(db, path!);
+        await setDoc(docRef, { array: arrayUnion(1, 2) }, { merge: true });
 
         // Document will be cached but we'll be missing 42.
-        const snapshot = await docRef.get({ source: 'cache' });
+        const snapshot = await getDocFromCache(docRef);
         expect(snapshot.data()).to.deep.equal({ array: [1, 2] });
       });
     });
 
     it('update() with cached base doc using arrayUnion()', async () => {
       await withTestDoc(persistence, async docRef => {
-        await docRef.set({ array: [42] });
-        await docRef.update({ array: FieldValue.arrayUnion(1, 2) });
-        const snapshot = await docRef.get({ source: 'cache' });
+        await setDoc(docRef, { array: [42] });
+        await updateDoc(docRef, { array: arrayUnion(1, 2) });
+        const snapshot = await getDocFromCache(docRef);
         expect(snapshot.data()).to.deep.equal({ array: [42, 1, 2] });
       });
     });
 
     it('update() with cached base doc using arrayRemove()', async () => {
       await withTestDoc(persistence, async docRef => {
-        await docRef.set({ array: [42, 1, 2] });
-        await docRef.update({ array: FieldValue.arrayRemove(1, 2) });
-        const snapshot = await docRef.get({ source: 'cache' });
+        await setDoc(docRef, { array: [42, 1, 2] });
+        await updateDoc(docRef, { array: arrayRemove(1, 2) });
+        const snapshot = await getDocFromCache(docRef);
         expect(snapshot.data()).to.deep.equal({ array: [42] });
       });
     });