659 lines
19 KiB
JavaScript
659 lines
19 KiB
JavaScript
const {
|
|
test2DocRef,
|
|
COL2_DOC_1,
|
|
COL2_DOC_1_ID,
|
|
COL2_DOC_1_PATH,
|
|
TEST2_COLLECTION_NAME,
|
|
resetTestCollectionDoc,
|
|
} = TestHelpers.firestore;
|
|
|
|
describe('firestore()', () => {
|
|
describe('DocumentReference', () => {
|
|
before(async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, COL2_DOC_1());
|
|
});
|
|
|
|
describe('class', () => {
|
|
it('should return instance methods', () => {
|
|
const document = test2DocRef(COL2_DOC_1_ID);
|
|
document.should.have.property('firestore');
|
|
// TODO: Remaining checks
|
|
});
|
|
});
|
|
|
|
describe('id', () => {
|
|
it('should return document id', () => {
|
|
const document = test2DocRef(COL2_DOC_1_ID);
|
|
document.id.should.equal(COL2_DOC_1_ID);
|
|
});
|
|
});
|
|
|
|
describe('parent', () => {
|
|
it('should return parent collection', () => {
|
|
const document = test2DocRef(COL2_DOC_1_ID);
|
|
document.parent.id.should.equal(TEST2_COLLECTION_NAME);
|
|
});
|
|
});
|
|
|
|
describe('collection()', () => {
|
|
it('should return a child collection', () => {
|
|
const document = test2DocRef(COL2_DOC_1_ID);
|
|
const collection = document.collection('pages');
|
|
collection.id.should.equal('pages');
|
|
});
|
|
|
|
it('should error if invalid collection path supplied', () => {
|
|
(() => {
|
|
test2DocRef(COL2_DOC_1_ID).collection('pages/page1');
|
|
}).should.throw(
|
|
'Argument "collectionPath" must point to a collection.'
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('delete()', () => {
|
|
it('should delete Document', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, COL2_DOC_1());
|
|
await test2DocRef(COL2_DOC_1_ID).delete();
|
|
const doc = await test2DocRef(COL2_DOC_1_ID).get();
|
|
should.equal(doc.exists, false);
|
|
});
|
|
});
|
|
|
|
describe('get()', () => {
|
|
it('DocumentSnapshot should have correct properties', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, COL2_DOC_1());
|
|
const snapshot = await test2DocRef(COL2_DOC_1_ID).get();
|
|
snapshot.id.should.equal(COL2_DOC_1_ID);
|
|
snapshot.metadata.should.be.an.Object();
|
|
});
|
|
|
|
it('should support GetOptions source=`default`', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, COL2_DOC_1());
|
|
const snapshot = await test2DocRef(COL2_DOC_1_ID).get({
|
|
source: 'default',
|
|
});
|
|
snapshot.id.should.equal(COL2_DOC_1_ID);
|
|
snapshot.metadata.should.be.an.Object();
|
|
should.equal(snapshot.metadata.fromCache, false);
|
|
});
|
|
|
|
it('should support GetOptions source=`server`', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, COL2_DOC_1());
|
|
const snapshot = await test2DocRef(COL2_DOC_1_ID).get({
|
|
source: 'server',
|
|
});
|
|
snapshot.id.should.equal(COL2_DOC_1_ID);
|
|
snapshot.metadata.should.be.an.Object();
|
|
should.equal(snapshot.metadata.fromCache, false);
|
|
});
|
|
|
|
// TODO: For some reason when using `cache` it's not seeing the data as available, even if
|
|
// first requesting it from the server, although interestingly it works fine in the old
|
|
// tests app
|
|
xit('should support GetOptions source=`cache`', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, COL2_DOC_1());
|
|
const ref = test2DocRef(COL2_DOC_1_ID);
|
|
// Make sure the reference data is populated in the cache
|
|
await ref.get({ source: 'server' });
|
|
// Retrieve the cached version
|
|
const snapshot = await ref.get({ source: 'cache' });
|
|
snapshot.id.should.equal(COL2_DOC_1_ID);
|
|
snapshot.metadata.should.be.an.Object();
|
|
should.equal(snapshot.metadata.fromCache, true);
|
|
});
|
|
|
|
it('should error with invalid GetOptions source option', async () => {
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
try {
|
|
await docRef.get(() => {});
|
|
return Promise.reject(
|
|
new Error('get() did not reject with invalid argument.')
|
|
);
|
|
} catch (e) {
|
|
// do nothing
|
|
}
|
|
try {
|
|
await docRef.get({ source: 'invalid' });
|
|
return Promise.reject(
|
|
new Error('get() did not reject with invalid source property.')
|
|
);
|
|
} catch (e) {
|
|
// do nothing
|
|
}
|
|
return Promise.resolve();
|
|
});
|
|
});
|
|
|
|
describe('onSnapshot()', () => {
|
|
it('calls callback with the initial data and then when value changes', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
const currentDataValue = { name: 'doc1' };
|
|
const newDataValue = { name: 'updated' };
|
|
|
|
const callback = sinon.spy();
|
|
|
|
// Test
|
|
|
|
let unsubscribe;
|
|
await new Promise(resolve2 => {
|
|
unsubscribe = docRef.onSnapshot(snapshot => {
|
|
callback(snapshot.data());
|
|
resolve2();
|
|
});
|
|
});
|
|
|
|
callback.should.be.calledWith(currentDataValue);
|
|
|
|
// Update the document
|
|
|
|
await docRef.set(newDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
// Assertions
|
|
|
|
callback.should.be.calledWith(newDataValue);
|
|
callback.should.be.calledTwice();
|
|
|
|
// Tear down
|
|
|
|
unsubscribe();
|
|
});
|
|
|
|
it("doesn't call callback when the ref is updated with the same value", async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
const currentDataValue = { name: 'doc1' };
|
|
|
|
const callback = sinon.spy();
|
|
|
|
// Test
|
|
|
|
let unsubscribe;
|
|
await new Promise(resolve2 => {
|
|
unsubscribe = docRef.onSnapshot(snapshot => {
|
|
callback(snapshot.data());
|
|
resolve2();
|
|
});
|
|
});
|
|
|
|
callback.should.be.calledWith(currentDataValue);
|
|
|
|
await docRef.set(currentDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
// Assertions
|
|
|
|
callback.should.be.calledOnce(); // Callback is not called again
|
|
|
|
// Tear down
|
|
|
|
unsubscribe();
|
|
});
|
|
|
|
it('allows binding multiple callbacks to the same ref', async () => {
|
|
// Setup
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
const currentDataValue = { name: 'doc1' };
|
|
const newDataValue = { name: 'updated' };
|
|
|
|
const callbackA = sinon.spy();
|
|
const callbackB = sinon.spy();
|
|
|
|
// Test
|
|
let unsubscribeA;
|
|
let unsubscribeB;
|
|
await new Promise(resolve2 => {
|
|
unsubscribeA = docRef.onSnapshot(snapshot => {
|
|
callbackA(snapshot.data());
|
|
resolve2();
|
|
});
|
|
});
|
|
|
|
await new Promise(resolve2 => {
|
|
unsubscribeB = docRef.onSnapshot(snapshot => {
|
|
callbackB(snapshot.data());
|
|
resolve2();
|
|
});
|
|
});
|
|
|
|
callbackA.should.be.calledWith(currentDataValue);
|
|
callbackA.should.be.calledOnce();
|
|
|
|
callbackB.should.be.calledWith(currentDataValue);
|
|
callbackB.should.be.calledOnce();
|
|
|
|
await docRef.set(newDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
callbackA.should.be.calledWith(newDataValue);
|
|
callbackB.should.be.calledWith(newDataValue);
|
|
|
|
callbackA.should.be.calledTwice();
|
|
callbackB.should.be.calledTwice();
|
|
|
|
// Tear down
|
|
|
|
unsubscribeA();
|
|
unsubscribeB();
|
|
});
|
|
|
|
it('listener stops listening when unsubscribed', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
|
|
// Setup
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
const currentDataValue = { name: 'doc1' };
|
|
const newDataValue = { name: 'updated' };
|
|
|
|
const callbackA = sinon.spy();
|
|
const callbackB = sinon.spy();
|
|
|
|
// Test
|
|
let unsubscribeA;
|
|
let unsubscribeB;
|
|
await new Promise(resolve2 => {
|
|
unsubscribeA = docRef.onSnapshot(snapshot => {
|
|
callbackA(snapshot.data());
|
|
resolve2();
|
|
});
|
|
});
|
|
|
|
await new Promise(resolve2 => {
|
|
unsubscribeB = docRef.onSnapshot(snapshot => {
|
|
callbackB(snapshot.data());
|
|
resolve2();
|
|
});
|
|
});
|
|
|
|
callbackA.should.be.calledWith(currentDataValue);
|
|
callbackA.should.be.calledOnce();
|
|
|
|
callbackB.should.be.calledWith(currentDataValue);
|
|
callbackB.should.be.calledOnce();
|
|
|
|
await docRef.set(newDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
callbackA.should.be.calledWith(newDataValue);
|
|
callbackB.should.be.calledWith(newDataValue);
|
|
|
|
callbackA.should.be.calledTwice();
|
|
callbackB.should.be.calledTwice();
|
|
|
|
// Unsubscribe A
|
|
|
|
unsubscribeA();
|
|
|
|
await docRef.set(currentDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
callbackB.should.be.calledWith(currentDataValue);
|
|
|
|
callbackA.should.be.calledTwice();
|
|
callbackB.should.be.calledThrice();
|
|
|
|
// Unsubscribe B
|
|
|
|
unsubscribeB();
|
|
|
|
await docRef.set(newDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
callbackA.should.be.calledTwice();
|
|
callbackB.should.be.calledThrice();
|
|
});
|
|
|
|
it('supports options and callbacks', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
const currentDataValue = { name: 'doc1' };
|
|
const newDataValue = { name: 'updated' };
|
|
|
|
const callback = sinon.spy();
|
|
|
|
// Test
|
|
|
|
let unsubscribe;
|
|
await new Promise(resolve2 => {
|
|
unsubscribe = docRef.onSnapshot(
|
|
{ includeMetadataChanges: true },
|
|
snapshot => {
|
|
callback(snapshot.data());
|
|
resolve2();
|
|
}
|
|
);
|
|
});
|
|
|
|
callback.should.be.calledWith(currentDataValue);
|
|
|
|
// Update the document
|
|
|
|
await docRef.set(newDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
// Assertions
|
|
|
|
callback.should.be.calledWith(newDataValue);
|
|
|
|
// Tear down
|
|
|
|
unsubscribe();
|
|
});
|
|
|
|
it('supports observer', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
const currentDataValue = { name: 'doc1' };
|
|
const newDataValue = { name: 'updated' };
|
|
|
|
const callback = sinon.spy();
|
|
|
|
// Test
|
|
|
|
let unsubscribe;
|
|
await new Promise(resolve2 => {
|
|
const observer = {
|
|
next: snapshot => {
|
|
callback(snapshot.data());
|
|
resolve2();
|
|
},
|
|
};
|
|
unsubscribe = docRef.onSnapshot(observer);
|
|
});
|
|
|
|
callback.should.be.calledWith(currentDataValue);
|
|
|
|
// Update the document
|
|
|
|
await docRef.set(newDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
// Assertions
|
|
|
|
callback.should.be.calledWith(newDataValue);
|
|
callback.should.be.calledTwice();
|
|
|
|
// Tear down
|
|
|
|
unsubscribe();
|
|
});
|
|
|
|
it('supports options and observer', async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
const currentDataValue = { name: 'doc1' };
|
|
const newDataValue = { name: 'updated' };
|
|
|
|
const callback = sinon.spy();
|
|
|
|
// Test
|
|
|
|
let unsubscribe;
|
|
await new Promise(resolve2 => {
|
|
const observer = {
|
|
next: snapshot => {
|
|
callback(snapshot.data());
|
|
resolve2();
|
|
},
|
|
error: () => {},
|
|
};
|
|
unsubscribe = docRef.onSnapshot(
|
|
{ includeMetadataChanges: true },
|
|
observer
|
|
);
|
|
});
|
|
|
|
callback.should.be.calledWith(currentDataValue);
|
|
|
|
// Update the document
|
|
|
|
await docRef.set(newDataValue);
|
|
|
|
await sleep(50);
|
|
|
|
// Assertions
|
|
|
|
callback.should.be.calledWith(newDataValue);
|
|
|
|
// Tear down
|
|
|
|
unsubscribe();
|
|
});
|
|
|
|
it('errors when invalid parameters supplied', async () => {
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
(() => {
|
|
docRef.onSnapshot(() => {}, 'error');
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: Second argument must be a valid function.'
|
|
);
|
|
(() => {
|
|
docRef.onSnapshot({
|
|
next: () => {},
|
|
error: 'error',
|
|
});
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: Observer.error must be a valid function.'
|
|
);
|
|
(() => {
|
|
docRef.onSnapshot({
|
|
next: 'error',
|
|
});
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: Observer.next must be a valid function.'
|
|
);
|
|
(() => {
|
|
docRef.onSnapshot(
|
|
{
|
|
includeMetadataChanges: true,
|
|
},
|
|
() => {},
|
|
'error'
|
|
);
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: Third argument must be a valid function.'
|
|
);
|
|
(() => {
|
|
docRef.onSnapshot(
|
|
{
|
|
includeMetadataChanges: true,
|
|
},
|
|
{
|
|
next: () => {},
|
|
error: 'error',
|
|
}
|
|
);
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: Observer.error must be a valid function.'
|
|
);
|
|
(() => {
|
|
docRef.onSnapshot(
|
|
{
|
|
includeMetadataChanges: true,
|
|
},
|
|
{
|
|
next: 'error',
|
|
}
|
|
);
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: Observer.next must be a valid function.'
|
|
);
|
|
(() => {
|
|
docRef.onSnapshot(
|
|
{
|
|
includeMetadataChanges: true,
|
|
},
|
|
'error'
|
|
);
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: Second argument must be a function or observer.'
|
|
);
|
|
(() => {
|
|
docRef.onSnapshot({
|
|
error: 'error',
|
|
});
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: First argument must be a function, observer or options.'
|
|
);
|
|
(() => {
|
|
docRef.onSnapshot();
|
|
}).should.throw(
|
|
'DocumentReference.onSnapshot failed: Called with invalid arguments.'
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('set()', () => {
|
|
before(async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
});
|
|
it('should create Document', async () => {
|
|
await test2DocRef('doc2').set({ name: 'doc2', testArray: [] });
|
|
const doc = await test2DocRef('doc2').get();
|
|
doc.data().name.should.equal('doc2');
|
|
});
|
|
|
|
it('should merge Document', async () => {
|
|
await test2DocRef(COL2_DOC_1_ID).set(
|
|
{ merge: 'merge' },
|
|
{ merge: true }
|
|
);
|
|
|
|
const doc = await test2DocRef(COL2_DOC_1_ID).get();
|
|
doc.data().name.should.equal('doc1');
|
|
doc.data().merge.should.equal('merge');
|
|
});
|
|
|
|
it('should overwrite Document', async () => {
|
|
await test2DocRef(COL2_DOC_1_ID).set({ name: 'overwritten' });
|
|
const doc = await test2DocRef(COL2_DOC_1_ID).get();
|
|
doc.data().name.should.equal('overwritten');
|
|
});
|
|
});
|
|
|
|
describe('update()', () => {
|
|
beforeEach(async () => {
|
|
await resetTestCollectionDoc(COL2_DOC_1_PATH, { name: 'doc1' });
|
|
});
|
|
|
|
it('should update Document using object', async () => {
|
|
await test2DocRef(COL2_DOC_1_ID).update({ name: 'updated' });
|
|
const doc = await test2DocRef(COL2_DOC_1_ID).get();
|
|
doc.data().name.should.equal('updated');
|
|
});
|
|
|
|
it('should update Document using key/value pairs', async () => {
|
|
await test2DocRef(COL2_DOC_1_ID).update('name', 'updated');
|
|
const doc = await test2DocRef(COL2_DOC_1_ID).get();
|
|
doc.data().name.should.equal('updated');
|
|
});
|
|
|
|
it('should update Document using FieldPath/value pair', async () => {
|
|
await test2DocRef(COL2_DOC_1_ID).update(
|
|
new firebase.firestore.FieldPath('name'),
|
|
'Name'
|
|
);
|
|
const doc = await test2DocRef(COL2_DOC_1_ID).get();
|
|
doc.data().name.should.equal('Name');
|
|
});
|
|
|
|
it('should update Document using nested FieldPath and value pair', async () => {
|
|
await test2DocRef(COL2_DOC_1_ID).update(
|
|
new firebase.firestore.FieldPath('nested', 'name'),
|
|
'Nested Name'
|
|
);
|
|
const doc = await test2DocRef(COL2_DOC_1_ID).get();
|
|
doc.data().nested.name.should.equal('Nested Name');
|
|
});
|
|
|
|
it('should update Document using multiple FieldPath/value pairs', async () => {
|
|
await test2DocRef(COL2_DOC_1_ID).update(
|
|
new firebase.firestore.FieldPath('nested', 'firstname'),
|
|
'First Name',
|
|
new firebase.firestore.FieldPath('nested', 'lastname'),
|
|
'Last Name'
|
|
);
|
|
const doc = await test2DocRef(COL2_DOC_1_ID).get();
|
|
doc.data().nested.firstname.should.equal('First Name');
|
|
doc.data().nested.lastname.should.equal('Last Name');
|
|
});
|
|
|
|
it('errors when invalid parameters supplied', async () => {
|
|
const docRef = test2DocRef(COL2_DOC_1_ID);
|
|
(() => {
|
|
docRef.update('error');
|
|
}).should.throw(
|
|
'DocumentReference.update failed: If using a single update argument, it must be an object.'
|
|
);
|
|
(() => {
|
|
docRef.update('error1', 'error2', 'error3');
|
|
}).should.throw(
|
|
'DocumentReference.update failed: The update arguments must be either a single object argument, or equal numbers of key/value pairs.'
|
|
);
|
|
(() => {
|
|
docRef.update(0, 'error');
|
|
}).should.throw(
|
|
'DocumentReference.update failed: Argument at index 0 must be a string or FieldPath'
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('types', () => {
|
|
it('should handle Boolean field', async () => {
|
|
const docRef = test2DocRef('reference');
|
|
await docRef.set({
|
|
field: true,
|
|
});
|
|
|
|
const doc = await docRef.get();
|
|
should.equal(doc.data().field, true);
|
|
});
|
|
|
|
it('should handle Date field', async () => {
|
|
const date = new bridge.context.window.Date();
|
|
const docRef = test2DocRef('reference');
|
|
await docRef.set({
|
|
field: date,
|
|
});
|
|
|
|
const doc = await docRef.get();
|
|
doc.data().field.should.be.instanceof(bridge.context.window.Date);
|
|
should.equal(doc.data().field.toISOString(), date.toISOString());
|
|
should.equal(doc.data().field.getTime(), date.getTime());
|
|
});
|
|
|
|
it('should handle DocumentReference field', async () => {
|
|
const docRef = test2DocRef('reference');
|
|
await docRef.set({
|
|
field: firebase.firestore().doc('test/field'),
|
|
});
|
|
|
|
const doc = await docRef.get();
|
|
should.equal(doc.data().field.path, 'test/field');
|
|
});
|
|
|
|
it('should handle GeoPoint field', async () => {
|
|
const docRef = test2DocRef('reference');
|
|
await docRef.set({
|
|
field: new firebase.firestore.GeoPoint(1.01, 1.02),
|
|
});
|
|
|
|
const doc = await docRef.get();
|
|
should.equal(doc.data().field.latitude, 1.01);
|
|
should.equal(doc.data().field.longitude, 1.02);
|
|
});
|
|
});
|
|
});
|
|
});
|