// Copyright 2017 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 {

DocumentData,

ExplainMetrics,

PartialWithFieldValue,

QuerySnapshot,

SetOptions,

Settings,

VectorValue,

WithFieldValue,

} from '@google-cloud/firestore';

import {afterEach, before, beforeEach, describe, it} from 'mocha';

import '../test/util/mocha_extensions';

import {expect, use} from 'chai';

import * as chaiAsPromised from 'chai-as-promised';

import * as extend from 'extend';

import {firestore} from '../protos/firestore_v1_proto_api';

import {

AggregateField,

CollectionReference,

DocumentReference,

DocumentSnapshot,

FieldPath,

FieldValue,

Firestore,

GeoPoint,

Query,

QueryDocumentSnapshot,

setLogFunction,

Timestamp,

WriteResult,

} from '../src';

import {autoId, Deferred} from '../src/util';

import {TEST_BUNDLE_ID, verifyMetadata} from '../test/bundle';

import {

bundleToElementArray,

isEnterprise,

Post,

postConverter,

postConverterMerge,

verifyInstance,

} from '../test/util/helpers';

import {BulkWriter} from '../src/bulk-writer';

import {Status} from 'google-gax';

import {QueryPartition} from '../src/query-partition';

import {CollectionGroup} from '../src/collection-group';

import IBundleElement = firestore.IBundleElement;

import {Filter} from '../src/filter';

import {IndexTestHelper} from './index_test_helper';

use(chaiAsPromised);

const version = require('../../package.json').version;

export class DeferredPromise<T> {

resolve: Function;

reject: Function;

promise: Promise<T> | null;

constructor() {

this.resolve = () => {

throw new Error('DeferredPromise.resolve has not been initialized');

};

this.reject = () => {

throw new Error('DeferredPromise.reject has not been initialized');

};

this.promise = null;

}

}

const firestoreEnv: {

[key: string]: string | undefined;

} = {};

for (const key in process.env) {

if (key.startsWith('FIRESTORE')) {

firestoreEnv[key] = process.env[key];

}

}

console.log(

`Running system tests with environment variables:\n ${JSON.stringify(

firestoreEnv,

null,

2,

)}`,

);

if (process.env.NODE_ENV === 'DEBUG') {

setLogFunction(console.log);

}

export function getTestDb(settings: Settings = {}): Firestore {

const internalSettings: Settings = {};

if (process.env.FIRESTORE_NAMED_DATABASE) {

internalSettings.databaseId = process.env.FIRESTORE_NAMED_DATABASE;

}

if (process.env.FIRESTORE_TARGET_BACKEND) {

switch (process.env.FIRESTORE_TARGET_BACKEND.toUpperCase()) {

case 'PROD': {

break;

}

case 'QA': {

internalSettings.host = 'staging-firestore.sandbox.googleapis.com';

break;

}

case 'NIGHTLY': {

internalSettings.host = 'test-firestore.sandbox.googleapis.com';

break;

}

default: {

break;

}

}

}

return new Firestore({

...internalSettings,

...settings, // caller settings take precedent over internal settings

});

}

export function getTestRoot(settings: Settings = {}): CollectionReference {

return getTestDb(settings).collection(`node_${version}_${autoId()}`);

}

describe('Firestore class', () => {

let firestore: Firestore;

let randomCol: CollectionReference;

beforeEach(() => {

randomCol = getTestRoot();

firestore = randomCol.firestore;

});

afterEach(() => verifyInstance(firestore));

it('has collection() method', () => {

const ref = firestore.collection('col');

expect(ref.id).to.equal('col');

});

it('has doc() method', () => {

const ref = firestore.doc('col/doc');

expect(ref.id).to.equal('doc');

});

it('has getAll() method', () => {

const ref1 = randomCol.doc('doc1');

const ref2 = randomCol.doc('doc2');

return Promise.all([ref1.set({foo: 'a'}), ref2.set({foo: 'a'})])

.then(() => {

return firestore.getAll(ref1, ref2);

})

.then(docs => {

expect(docs.length).to.equal(2);

});

});

it.skipEnterprise('can plan a query using default options', async () => {

await randomCol.doc('doc1').set({foo: 1});

await randomCol.doc('doc2').set({foo: 2});

await randomCol.doc('doc3').set({foo: 1});

const explainResults = await randomCol.where('foo', '>', 1).explain();

// Should have metrics.

const metrics = explainResults.metrics;

expect(metrics).to.not.be.null;

// Should have query plan.

const plan = metrics.planSummary;

expect(plan).to.not.be.null;

expect(Object.keys(plan.indexesUsed).length).to.be.greaterThan(0);

// No execution stats and no snapshot.

expect(metrics.executionStats).to.be.null;

expect(explainResults.snapshot).to.be.null;

});

it.skipEnterprise('can plan a query', async () => {

await randomCol.doc('doc1').set({foo: 1});

await randomCol.doc('doc2').set({foo: 2});

await randomCol.doc('doc3').set({foo: 1});

const explainResults = await randomCol

.where('foo', '>', 1)

.explain({analyze: false});

// Should have metrics.

const metrics = explainResults.metrics;

expect(metrics).to.not.be.null;

// Should have query plan.

const plan = metrics.planSummary;

expect(plan).to.not.be.null;

expect(Object.keys(plan.indexesUsed).length).to.be.greaterThan(0);

// No execution stats and no snapshot.

expect(metrics.executionStats).to.be.null;

expect(explainResults.snapshot).to.be.null;

});

it.skipEnterprise('can profile a query', async () => {

await randomCol.doc('doc1').set({foo: 1, bar: 0});

await randomCol.doc('doc2').set({foo: 2, bar: 1});

await randomCol.doc('doc3').set({foo: 1, bar: 2});

const explainResults = await randomCol

.where('foo', '==', 1)

.explain({analyze: true});

const metrics = explainResults.metrics;

expect(metrics.planSummary).to.not.be.null;

expect(metrics.executionStats).to.not.be.null;

expect(explainResults.snapshot).to.not.be.null;

expect(

Object.keys(metrics.planSummary.indexesUsed).length,

).to.be.greaterThan(0);

const stats = metrics.executionStats!;

expect(stats.readOperations).to.be.greaterThan(0);

expect(stats.resultsReturned).to.be.equal(2);

expect(

stats.executionDuration.nanoseconds > 0 ||

stats.executionDuration.seconds > 0,

).to.be.true;

expect(Object.keys(stats.debugStats).length).to.be.greaterThan(0);

expect(explainResults.snapshot!.size).to.equal(2);

});

it.skipEnterprise(

'can profile a query that does not match any docs',

async () => {

await randomCol.doc('doc1').set({foo: 1, bar: 0});

await randomCol.doc('doc2').set({foo: 2, bar: 1});

await randomCol.doc('doc3').set({foo: 1, bar: 2});

const results = await randomCol.where('foo', '==', 12345).get();

expect(results.empty).to.be.true;

expect(results.docs.length).to.equal(0);

expect(results.readTime.toMillis()).to.be.greaterThan(0);

const explainResults = await randomCol

.where('foo', '==', 12345)

.explain({analyze: true});

const metrics = explainResults.metrics;

expect(metrics.planSummary).to.not.be.null;

expect(metrics.executionStats).to.not.be.null;

expect(explainResults.snapshot).to.not.be.null;

expect(

Object.keys(metrics.planSummary.indexesUsed).length,

).to.be.greaterThan(0);

const stats = metrics.executionStats!;

expect(stats.readOperations).to.be.greaterThan(0);

expect(stats.resultsReturned).to.be.equal(0);

expect(

stats.executionDuration.nanoseconds > 0 ||

stats.executionDuration.seconds > 0,

).to.be.true;

expect(Object.keys(stats.debugStats).length).to.be.greaterThan(0);

expect(explainResults.snapshot!.size).to.equal(0);

},

);

it.skipEnterprise(

'can stream explain results with default options',

async () => {

await randomCol.doc('doc1').set({foo: 1, bar: 0});

await randomCol.doc('doc2').set({foo: 2, bar: 1});

await randomCol.doc('doc3').set({foo: 1, bar: 2});

let totalResponses = 0;

let totalDocuments = 0;

let metrics: ExplainMetrics | null = null;

const stream = randomCol.explainStream();

const promise = new Promise<boolean>((resolve, reject) => {

stream.on('data', data => {

++totalResponses;

if (data.document) {

++totalDocuments;

}

if (data.metrics) {

metrics = data.metrics;

}

});

stream.on('end', () => {

expect(totalResponses).to.equal(1);

expect(totalDocuments).to.equal(0);

expect(metrics).to.not.be.null;

expect(metrics!.planSummary.indexesUsed.length).to.be.greaterThan(0);

expect(metrics!.executionStats).to.be.null;

resolve(true);

});

stream.on('error', (error: Error) => {

reject(error);

});

});

const success: boolean = await promise;

expect(success).to.be.true;

},

);

it.skipEnterprise('can stream explain results without analyze', async () => {

await randomCol.doc('doc1').set({foo: 1, bar: 0});

await randomCol.doc('doc2').set({foo: 2, bar: 1});

await randomCol.doc('doc3').set({foo: 1, bar: 2});

let totalResponses = 0;

let totalDocuments = 0;

let metrics: ExplainMetrics | null = null;

const stream = randomCol.explainStream({analyze: false});

const promise = new Promise<boolean>((resolve, reject) => {

stream.on('data', data => {

++totalResponses;

if (data.document) {

++totalDocuments;

}

if (data.metrics) {

metrics = data.metrics;

}

});

stream.on('end', () => {

expect(totalResponses).to.equal(1);

expect(totalDocuments).to.equal(0);

expect(metrics).to.not.be.null;

expect(metrics!.planSummary.indexesUsed.length).to.be.greaterThan(0);

expect(metrics!.executionStats).to.be.null;

resolve(true);

});

stream.on('error', (error: Error) => {

reject(error);

});

});

const success: boolean = await promise;

expect(success).to.be.true;

});

it.skipEnterprise('can stream explain results with analyze', async () => {

await randomCol.doc('doc1').set({foo: 1, bar: 0});

await randomCol.doc('doc2').set({foo: 2, bar: 1});

await randomCol.doc('doc3').set({foo: 1, bar: 2});

let totalResponses = 0;

let totalDocuments = 0;

let metrics: ExplainMetrics | null = null;

const stream = randomCol

.where('foo', '==', 1)

.explainStream({analyze: true});

const promise = new Promise<boolean>((resolve, reject) => {

stream.on('data', data => {

++totalResponses;

if (data.document) {

++totalDocuments;

}

if (data.metrics) {

metrics = data.metrics;

}

});

stream.on('end', () => {

expect(totalResponses).to.equal(2);

expect(totalDocuments).to.equal(2);

expect(metrics).to.not.be.null;

expect(metrics!.planSummary.indexesUsed.length).to.be.greaterThan(0);

expect(metrics!.executionStats).to.not.be.null;

expect(metrics!.executionStats!.resultsReturned).to.equal(2);

resolve(true);

});

stream.on('error', (error: Error) => {

reject(error);

});

});

const success: boolean = await promise;

expect(success).to.be.true;

});

it.skipEnterprise(

'can plan an aggregate query using default options',

async () => {

await randomCol.doc('doc1').set({foo: 1});

await randomCol.doc('doc2').set({foo: 2});

await randomCol.doc('doc3').set({foo: 1});

const explainResults = await randomCol

.where('foo', '>', 0)

.count()

.explain();

const metrics = explainResults.metrics;

const plan = metrics.planSummary;

expect(plan).to.not.be.null;

expect(Object.keys(plan.indexesUsed).length).to.be.greaterThan(0);

expect(metrics.executionStats).to.be.null;

expect(explainResults.snapshot).to.be.null;

},

);

it.skipEnterprise('can plan an aggregate query', async () => {

await randomCol.doc('doc1').set({foo: 1});

await randomCol.doc('doc2').set({foo: 2});

await randomCol.doc('doc3').set({foo: 1});

const explainResults = await randomCol

.where('foo', '>', 0)

.count()

.explain({analyze: false});

const metrics = explainResults.metrics;

const plan = metrics.planSummary;

expect(plan).to.not.be.null;

expect(Object.keys(plan.indexesUsed).length).to.be.greaterThan(0);

expect(metrics.executionStats).to.be.null;

expect(explainResults.snapshot).to.be.null;

});

it.skipEnterprise('can profile an aggregate query', async () => {

await randomCol.doc('doc1').set({foo: 1});

await randomCol.doc('doc2').set({foo: 2});

await randomCol.doc('doc3').set({foo: 1});

const explainResults = await randomCol

.where('foo', '<', 3)

.count()

.explain({analyze: true});

const metrics = explainResults.metrics;

expect(metrics.planSummary).to.not.be.null;

expect(

Object.keys(metrics.planSummary.indexesUsed).length,

).to.be.greaterThan(0);

expect(metrics.executionStats).to.not.be.null;

const stats = metrics.executionStats!;

expect(stats.readOperations).to.be.greaterThan(0);

expect(stats.resultsReturned).to.be.equal(1);

expect(

stats.executionDuration.nanoseconds > 0 ||

stats.executionDuration.seconds > 0,

).to.be.true;

expect(Object.keys(stats.debugStats).length).to.be.greaterThan(0);

expect(explainResults.snapshot).to.not.be.null;

expect(explainResults.snapshot!.data().count).to.equal(3);

});

it.skipEnterprise('can plan a vector query', async () => {

const indexTestHelper = new IndexTestHelper(firestore);

const collectionReference = await indexTestHelper.createTestDocs([

{foo: 'bar'},

{foo: 'xxx', embedding: FieldValue.vector([10, 10])},

{foo: 'bar', embedding: FieldValue.vector([1, 1])},

{foo: 'bar', embedding: FieldValue.vector([10, 0])},

{foo: 'bar', embedding: FieldValue.vector([20, 0])},

{foo: 'bar', embedding: FieldValue.vector([100, 100])},

]);

const explainResults = await indexTestHelper

.query(collectionReference)

.findNearest({

vectorField: 'embedding',

queryVector: FieldValue.vector([1, 3]),

limit: 10,

distanceMeasure: 'COSINE',

})

.explain({analyze: false});

const metrics = explainResults.metrics;

const plan = metrics.planSummary;

expect(plan).to.not.be.null;

expect(Object.keys(plan.indexesUsed).length).to.be.greaterThan(0);

expect(metrics.executionStats).to.be.null;

expect(explainResults.snapshot).to.be.null;

});

it.skipEnterprise('can profile a vector query', async () => {

const indexTestHelper = new IndexTestHelper(firestore);

const collectionReference = await indexTestHelper.createTestDocs([

{foo: 'bar'},

{foo: 'xxx', embedding: FieldValue.vector([10, 10])},

{foo: 'bar', embedding: FieldValue.vector([1, 1])},

{foo: 'bar', embedding: FieldValue.vector([10, 0])},

{foo: 'bar', embedding: FieldValue.vector([20, 0])},

{foo: 'bar', embedding: FieldValue.vector([100, 100])},

]);

const explainResults = await indexTestHelper

.query(collectionReference)

.findNearest({

vectorField: 'embedding',

queryVector: FieldValue.vector([1, 3]),

limit: 10,

distanceMeasure: 'COSINE',

})

.explain({analyze: true});

const metrics = explainResults.metrics;

expect(metrics.planSummary).to.not.be.null;

expect(

Object.keys(metrics.planSummary.indexesUsed).length,

).to.be.greaterThan(0);

expect(metrics.executionStats).to.not.be.null;

const stats = metrics.executionStats!;

expect(stats.readOperations).to.be.greaterThan(0);

expect(stats.resultsReturned).to.be.equal(5);

expect(

stats.executionDuration.nanoseconds > 0 ||

stats.executionDuration.seconds > 0,

).to.be.true;

expect(Object.keys(stats.debugStats).length).to.be.greaterThan(0);

expect(explainResults.snapshot).to.not.be.null;

expect(explainResults.snapshot!.docs.length).to.equal(5);

});

it('getAll() supports array destructuring', () => {

const ref1 = randomCol.doc('doc1');

const ref2 = randomCol.doc('doc2');

return Promise.all([ref1.set({foo: 'a'}), ref2.set({foo: 'a'})])

.then(() => {

return firestore.getAll(...[ref1, ref2]);

})

.then(docs => {

expect(docs.length).to.equal(2);

});

});

it('getAll() supports field mask', () => {

const ref1 = randomCol.doc('doc1');

return ref1

.set({foo: 'a', bar: 'b'})

.then(() => {

return firestore.getAll(ref1, {fieldMask: ['foo']});

})

.then(docs => {

expect(docs[0].data()).to.deep.equal({foo: 'a'});

});

});

it('getAll() supports array destructuring with field mask', () => {

const ref1 = randomCol.doc('doc1');

const ref2 = randomCol.doc('doc2');

return Promise.all([ref1.set({f: 'a', b: 'b'}), ref2.set({f: 'a', b: 'b'})])

.then(() => {

return firestore.getAll(...[ref1, ref2], {fieldMask: ['f']});

})

.then(docs => {

expect(docs[0].data()).to.deep.equal({f: 'a'});

expect(docs[1].data()).to.deep.equal({f: 'a'});

});

});

it('getAll() supports generics', async () => {

const ref1 = randomCol.doc('doc1').withConverter(postConverter);

const ref2 = randomCol.doc('doc2').withConverter(postConverter);

await ref1.set(new Post('post1', 'author1'));

await ref2.set(new Post('post2', 'author2'));

const docs = await firestore.getAll(ref1, ref2);

expect(docs[0].data()!.toString()).to.deep.equal('post1, by author1');

expect(docs[1].data()!.toString()).to.deep.equal('post2, by author2');

});

it('cannot make calls after the client has been terminated', async () => {

const ref1 = randomCol.doc('doc1');

await firestore.terminate();

return expect(ref1.set({foo: 100})).to.eventually.be.rejectedWith(

'The client has already been terminated',

);

});

it('throws an error if terminate() is called with active listeners', async () => {

const ref = randomCol.doc('doc-1');

const unsubscribe = ref.onSnapshot(() => {

// No-op

});

await expect(firestore.terminate()).to.eventually.be.rejectedWith(

'All onSnapshot() listeners must be unsubscribed, and all BulkWriter ' +

'instances must be closed before terminating the client. There are 1 ' +

'active listeners and 0 open BulkWriter instances.',

);

unsubscribe();

});

it('throws an error if terminate() is called with pending BulkWriter operations', async () => {

const writer = firestore.bulkWriter();

const ref = randomCol.doc('doc-1');

void writer.set(ref, {foo: 'bar'});

await expect(firestore.terminate()).to.eventually.be.rejectedWith(

'All onSnapshot() listeners must be unsubscribed, and all BulkWriter ' +

'instances must be closed before terminating the client. There are 0 ' +

'active listeners and 1 open BulkWriter instances.',

);

});

});

// Skip partition query tests when running against the emulator because

// partition queries are not supported by the emulator.

describe.skipEmulator.skipEnterprise('CollectionGroup class', () => {

const desiredPartitionCount = 3;

const documentCount = 2 * 128 + 127; // Minimum partition size is 128.

let firestore: Firestore;

let randomColl: CollectionReference;

let collectionGroup: CollectionGroup;

before(async () => {

randomColl = getTestRoot();

firestore = randomColl.firestore;

collectionGroup = firestore.collectionGroup(randomColl.id);

const batch = firestore.batch();

for (let i = 0; i < documentCount; ++i) {

batch.create(randomColl.doc(), {title: 'post', author: 'author'});

}

await batch.commit();

});

async function getPartitions<T>(

collectionGroup: CollectionGroup<T>,

desiredPartitionsCount: number,

): Promise<QueryPartition<T>[]> {

const partitions: QueryPartition<T>[] = [];

for await (const partition of collectionGroup.getPartitions(

desiredPartitionsCount,

)) {

partitions.push(partition);

}

return partitions;

}

async function verifyPartitions<T>(

partitions: QueryPartition<T>[],

): Promise<QueryDocumentSnapshot<T>[]> {

expect(partitions.length).to.not.be.greaterThan(desiredPartitionCount);

expect(partitions[0].startAt).to.be.undefined;

for (let i = 0; i < partitions.length - 1; ++i) {

// The cursor value is a single DocumentReference

expect(

(partitions[i].endBefore![0] as DocumentReference<T>).isEqual(

partitions[i + 1].startAt![0] as DocumentReference<T>,

),

).to.be.true;

}

expect(partitions[partitions.length - 1].endBefore).to.be.undefined;

// Validate that we can use the partitions to read the original documents.

const documents: QueryDocumentSnapshot<T>[] = [];

for (const partition of partitions) {

documents.push(...(await partition.toQuery().get()).docs);

}

expect(documents.length).to.equal(documentCount);

return documents;

}

it('partition query', async () => {

const partitions = await getPartitions(

collectionGroup,

desiredPartitionCount,

);

await verifyPartitions(partitions);

});

it('partition query with manual cursors', async () => {

const partitions = await getPartitions(

collectionGroup,

desiredPartitionCount,

);

const documents: QueryDocumentSnapshot<DocumentData>[] = [];

for (const partition of partitions) {

let partitionedQuery: Query = collectionGroup.orderBy(

FieldPath.documentId(),

);

if (partition.startAt) {

partitionedQuery = partitionedQuery.startAt(...partition.startAt);

}

if (partition.endBefore) {

partitionedQuery = partitionedQuery.endBefore(...partition.endBefore);

}

documents.push(...(await partitionedQuery.get()).docs);

}

expect(documents.length).to.equal(documentCount);

});

it('partition query with converter', async () => {

const collectionGroupWithConverter =

collectionGroup.withConverter(postConverter);

const partitions = await getPartitions(

collectionGroupWithConverter,

desiredPartitionCount,

);

const documents = await verifyPartitions(partitions);

for (const document of documents) {

expect(document.data()).to.be.an.instanceOf(Post);

}

});

it('empty partition query', async () => {

const desiredPartitionCount = 3;

const collectionGroupId = randomColl.doc().id;

const collectionGroup = firestore.collectionGroup(collectionGroupId);

const partitions = await getPartitions(

collectionGroup,

desiredPartitionCount,

);

expect(partitions.length).to.equal(1);

expect(partitions[0].startAt).to.be.undefined;

expect(partitions[0].endBefore).to.be.undefined;

});

});

describe('CollectionReference class', () => {

let firestore: Firestore;

let randomCol: CollectionReference;

beforeEach(() => {

randomCol = getTestRoot();

firestore = randomCol.firestore;

});

afterEach(() => verifyInstance(firestore));

it('has firestore property', () => {

const ref = firestore.collection('col');

expect(ref.firestore).to.be.an.instanceOf(Firestore);

});

it('has id property', () => {

const ref = firestore.collection('col');

expect(ref.id).to.equal('col');

});

it('has parent property', () => {

const ref = firestore.collection('col/doc/col');

expect(ref.parent!.id).to.equal('doc');

});

it('has path property', () => {

const ref = firestore.collection('col/doc/col');

expect(ref.path).to.equal('col/doc/col');

});

it('has doc() method', () => {

let ref = firestore.collection('col').doc('doc');

expect(ref.id).to.equal('doc');

ref = firestore.collection('col').doc();

expect(ref.id).to.have.length(20);

});

it('has add() method', () => {

return randomCol

.add({foo: 'a'})

.then(ref => {

return ref.get();

})

.then(doc => {

expect(doc.get('foo')).to.equal('a');

});

});

// showMissing is not supported in Enterprise

it.skipEnterprise('lists missing documents', async () => {

const batch = firestore.batch();

batch.set(randomCol.doc('a'), {});

batch.set(randomCol.doc('b/b/b'), {});

batch.set(randomCol.doc('c'), {});

await batch.commit();

const documentRefs = await randomCol.listDocuments();

const documents = await firestore.getAll(...documentRefs);

const existingDocs = documents.filter(doc => doc.exists);

const missingDocs = documents.filter(doc => !doc.exists);

expect(existingDocs.map(doc => doc.id)).to.have.members(['a', 'c']);

expect(missingDocs.map(doc => doc.id)).to.have.members(['b']);

});

// showMissing is not supported in Enterprise

it.skipEnterprise(

'lists documents (more than the max page size)',

async () => {

const batch = firestore.batch();

const expectedResults = [];

for (let i = 0; i < 400; i++) {

const docRef = randomCol.doc(`${i}`.padStart(3, '0'));

batch.set(docRef, {id: i});

expectedResults.push(docRef.id);

}

await batch.commit();

const documentRefs = await randomCol.listDocuments();

const actualDocIds = documentRefs

.map(dr => dr.id)

.sort((a, b) => a.localeCompare(b));

expect(actualDocIds).to.deep.equal(expectedResults);

},

);

it('supports withConverter()', async () => {

const ref = await firestore

.collection('col')

.withConverter(postConverter)

.add(new Post('post', 'author'));

const postData = await ref.get();

const post = postData.data();

expect(post).to.not.be.undefined;

expect(post!.toString()).to.equal('post, by author');

});

});

describe('DocumentReference class', () => {

let firestore: Firestore;

let randomCol: CollectionReference;

beforeEach(() => {

randomCol = getTestRoot();

firestore = randomCol.firestore;

});

afterEach(() => verifyInstance(firestore));

it('has firestore property', () => {

const ref = firestore.doc('col/doc');

expect(ref.firestore).to.be.an.instanceOf(Firestore);

});

it('has id property', () => {

const ref = firestore.doc('col/doc');

expect(ref.id).to.equal('doc');

});

it('has parent property', () => {

const ref = firestore.doc('col/doc');

expect(ref.parent.id).to.equal('col');

});

it('has path property', () => {

const ref = firestore.doc('col/doc');

expect(ref.path).to.equal('col/doc');

});

it('has collection() method', () => {

const ref = firestore.doc('col/doc').collection('subcol');

expect(ref.id).to.equal('subcol');

});

it('has create()/get() method', () => {

const ref = randomCol.doc();

return ref

.create({foo: 'a'})

.then(() => {

return ref.get();

})

.then(doc => {

expect(doc.get('foo')).to.equal('a');

});

});

it('has set() method', () => {

const allSupportedTypesObject: {[field: string]: unknown} = {

stringValue: 'a',

trueValue: true,

falseValue: false,

integerValue: 10,

largeIntegerValue: 1234567890000,

doubleValue: 0.1,

infinityValue: Infinity,

negativeInfinityValue: -Infinity,

objectValue: {foo: 'bar', '😀': '😜'},

emptyObject: {},

dateValue: new Timestamp(479978400, 123000000),

zeroDateValue: new Timestamp(0, 0),

pathValue: firestore.doc('col1/ref1'),

arrayValue: ['foo', 42, 'bar'],

emptyArray: [],

nilValue: null,

geoPointValue: new GeoPoint(50.1430847, -122.947778),

zeroGeoPointValue: new GeoPoint(0, 0),

bytesValue: Buffer.from([0x01, 0x02]),

};

const ref = randomCol.doc('doc');

return ref

.set(allSupportedTypesObject)

.then(() => {

return ref.get();

})

.then(doc => {

const data = doc.data()!;

expect(data.pathValue.path).to.equal(

(allSupportedTypesObject.pathValue as DocumentReference).path,

);

delete data.pathValue;

delete allSupportedTypesObject.pathValue;

expect(data).to.deep.equal(allSupportedTypesObject);

});

});

it('supports NaNs', () => {

const nanObject = {

nanValue: NaN,

};

const ref = randomCol.doc('doc');

return ref

.set(nanObject)

.then(() => {

return ref.get();

})

.then(doc => {

const actualValue = doc.data()!.nanValue;

expect(actualValue).to.be.a('number');

expect(actualValue).to.be.NaN;

});

});

it('round-trips BigInts', () => {

const bigIntValue = BigInt(Number.MAX_SAFE_INTEGER) + BigInt(1);

const randomCol = getTestRoot({useBigInt: true});

const ref = randomCol.doc('doc');

return ref

.set({bigIntValue})

.then(() => ref.get())

.then(doc => ref.set(doc.data()!))

.then(() => ref.get())

.then(doc => {

const actualValue = doc.data()!.bigIntValue;

expect(actualValue).to.be.a('bigint');

expect(actualValue).to.equal(bigIntValue);

});

});

it('supports server timestamps', () => {

const baseObject = {

a: 'bar',

b: {remove: 'bar'},

d: {keep: 'bar'},

f: FieldValue.serverTimestamp(),

};

const updateObject = {

a: FieldValue.serverTimestamp(),

b: {c: FieldValue.serverTimestamp()},

'd.e': FieldValue.serverTimestamp(),

};

const ref = randomCol.doc('doc');

let setTimestamp: Timestamp;

return ref

.set(baseObject)

.then(() => {

return ref.get();

})

.then(doc => {

setTimestamp = doc.get('f');

expect(setTimestamp).to.be.an.instanceOf(Timestamp);

expect(doc.data()).to.deep.equal({

a: 'bar',

b: {remove: 'bar'},

d: {keep: 'bar'},

f: setTimestamp,

});

return ref.update(updateObject);

})

.then(() => {