chore: add e2e test for vector value

Author: Pelleking

packages/firestore/__tests__/firestore.test.ts

@@ -1431,4 +1431,41 @@ describe('Firestore', function () {
       });
     });
   });
+
+  describe('VectorValue (unit serializer)', function () {
+    it('constructs and validates values', function () {
+      const { default: FirestoreVectorValue } = require('../lib/FirestoreVectorValue');
+      const v = new FirestoreVectorValue([0, 1.5, -2]);
+      expect(v.values).toEqual([0, 1.5, -2]);
+      expect(v.isEqual(new FirestoreVectorValue([0, 1.5, -2]))).toBe(true);
+      expect(v.isEqual(new FirestoreVectorValue([0, 1.5]))).toBe(false);
+    });
+
+    it('serializes to type map and parses back', function () {
+      const { default: FirestoreVectorValue } = require('../lib/FirestoreVectorValue');
+      const serialize = require('../lib/utils/serialize');
+      const { getTypeMapName } = require('../lib/utils/typemap');
+
+      const v = new FirestoreVectorValue([0.1, 0.2, 0.3]);
+      const typed = serialize.generateNativeData(v, false);
+      expect(Array.isArray(typed)).toBe(true);
+      expect(getTypeMapName(typed[0])).toBe('vector');
+      const parsed = serialize.parseNativeData(null, typed);
+      expect(parsed instanceof FirestoreVectorValue).toBe(true);
+      expect(parsed.values).toEqual([0.1, 0.2, 0.3]);
+    });
+
+    it('serializes inside objects and arrays', function () {
+      const { default: FirestoreVectorValue } = require('../lib/FirestoreVectorValue');
+      const serialize = require('../lib/utils/serialize');
+      const { getTypeMapName } = require('../lib/utils/typemap');
+
+      const v = new FirestoreVectorValue([1, 2, 3]);
+      const map = serialize.buildNativeMap({ a: v }, false);
+      expect(getTypeMapName(map.a[0])).toBe('vector');
+
+      const arr = serialize.buildNativeArray([v], false);
+      expect(getTypeMapName(arr[0][0])).toBe('vector');
+    });
+  });
 });

packages/firestore/__tests__/vector.test.ts

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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.
+ *
+ */
+
+describe('firestore.VectorValue', function () {
+  describe('v8 compatibility', function () {
+    beforeEach(async function beforeEachTest() {
+      // @ts-ignore
+      globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = true;
+    });
+
+    afterEach(async function afterEachTest() {
+      // @ts-ignore
+      globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = false;
+    });
+
+    function ref(id) {
+      return firebase.firestore().doc(`e2e_vector/${id}`);
+    }
+
+    it('writes and reads a vector', async function () {
+      const r = ref('basic');
+      await r.set({ embedding: firebase.firestore.vector([0.12, 0.34, 0.56]) });
+
+      const snap = await r.get();
+      const v = snap.get('embedding');
+      should.exist(v);
+      v.values.should.eql([0.12, 0.34, 0.56]);
+    });
+
+    it('supports vectors in nested structures', async function () {
+      const r = ref('nested');
+      await r.set({
+        a: { b: firebase.firestore.vector([1, 2, 3]) },
+        arr: [firebase.firestore.vector([4, 5])],
+      });
+
+      const snap = await r.get();
+      snap.get('a').b.values.should.eql([1, 2, 3]);
+      snap.get('arr')[0].values.should.eql([4, 5]);
+    });
+
+    it('updates a vector field', async function () {
+      const r = ref('update');
+      await r.set({ x: 1 });
+      await r.update({ embedding: firebase.firestore.vector([9, 8, 7]) });
+
+      const snap = await r.get();
+      snap.get('embedding').values.should.eql([9, 8, 7]);
+    });
+
+    it('batch writes a vector', async function () {
+      const r = ref('batch');
+      const batch = firebase.firestore().batch();
+      batch.set(r, { embedding: firebase.firestore.vector([0.1, 0.2]) });
+      await batch.commit();
+
+      const snap = await r.get();
+      snap.get('embedding').values.should.eql([0.1, 0.2]);
+    });
+
+    it('transaction writes a vector', async function () {
+      const r = ref('transaction');
+      await firebase.firestore().runTransaction(async tx => {
+        tx.set(r, { embedding: firebase.firestore.vector([3.14, 2.72]) });
+      });
+
+      const snap = await r.get();
+      snap.get('embedding').values.should.eql([3.14, 2.72]);
+    });
+  });
+
+  describe('modular', function () {
+    function ref(id) {
+      // @ts-ignore test env provides firestoreModular
+      return firestoreModular.doc(firestoreModular.getFirestore(), `e2e_vector/${id}`);
+    }
+
+    it('writes and reads using modular vector()', async function () {
+      // @ts-ignore test env provides firestoreModular
+      const { setDoc, getDoc, vector } = firestoreModular;
+      const r = ref('modular-basic');
+      await setDoc(r, { embedding: vector([0.5, 0.25]) });
+      const snap = await getDoc(r);
+      const v = snap.get('embedding');
+      should.exist(v);
+      v.values.should.eql([0.5, 0.25]);
+    });
+  });
+});