Initial tables tests (#82)

* a bunch of tests work

* couple minor test fixes

Author: toptobes

DEVGUIDE.md

@@ -277,8 +277,8 @@ The most prominent changes are the introduction of 5 new Mocha-API-esque functio
    - Some suite options to reduce boilerplate
       - `truncateColls: 'default'` - Does `deleteMany({})` on the default collection in the default namespace after each test case
       - `truncateColls: 'both'` - Does `deleteMany({})` on the default collection in both test namespaces after each test case
-      - `dropEphemeral: 'after'` - Drops all non-default collections in both test namespaces after all the test cases in the suite
-      - `dropEphemeral: 'afterEach'` - Drops all non-default collections in both test namespaces each test case
+      - `drop: 'after'` - Drops all non-default collections in both test namespaces after all the test cases in the suite
+      - `drop: 'afterEach'` - Drops all non-default collections in both test namespaces each test case
 - [`it`](https://github.com/datastax/astra-db-ts/blob/60fa445192b6a648b7a139a45986af8525a37ffb/tests/testlib/it.ts) - An overhaul to the existing `it` block
    - Performs "tag filtering" on the test names
    - Provides unique string keys for every test case

src/db/types/tables/table-schema.ts

@@ -280,13 +280,13 @@ interface CqlNonGenericType2TSTypeDict {
   uuid: UUID | null,
   varchar: string | null,
   varint: bigint | null,
-  vector: DataAPIVector | null,
 }
 
 interface CqlGenericType2TSTypeDict<Def> {
   map: CqlMapType2TsType<Def>,
   list: CqlListType2TsType<Def>,
   set: CqlSetType2TsType<Def>,
+  vector: CqlVectorType2TsType<Def> | null,
 }
 
 type CqlMapType2TsType<Def> =
@@ -303,3 +303,8 @@ type CqlSetType2TsType<Def> =
   Def extends { valueType: infer ValueType extends string }
     ? Set<CqlType2TSType<ValueType, never> & {}>
     : TypeErr<'Invalid generics definition for \'set\'; should have valueType set as scalar CQL types (e.g. \'text\')'>;
+
+type CqlVectorType2TsType<Def> =
+  Def extends { service: unknown }
+    ? DataAPIVector | string
+    : DataAPIVector;

src/documents/tables/ser-des.ts

@@ -108,11 +108,18 @@ const DefaultTableSerDesCfg = {
         return [[...value]];
       }
 
-      if (!ctx.bigNumsPresent && value instanceof BigNumber) {
+      if (value instanceof BigNumber) {
         ctx.bigNumsPresent = true;
+        return true;
       }
     } else if (!ctx.bigNumsPresent && typeof value === 'bigint') {
       ctx.bigNumsPresent = true;
+      return true;
+    } else if (typeof value === 'number') {
+      if (!isFinite(value)) {
+        return [value.toString(), true];
+      }
+      return [value, true];
     }
   },
   deserialize(key, _, ctx) {

tests/integration/db/db.test.ts

@@ -28,7 +28,7 @@ import { DataAPIResponseError } from '@/src/documents';
 import { DataAPIClient } from '@/src/client';
 import { DEFAULT_DATA_API_PATHS, DEFAULT_KEYSPACE } from '@/src/lib/api/constants';
 
-parallel('integration.db', { dropEphemeral: 'colls:after' }, ({ db }) => {
+parallel('integration.db', { drop: 'colls:after' }, ({ db }) => {
   describe('(LONG) createCollection', () => {
     it('should create a collections', async () => {
       const res = await db.createCollection('coll_1c', { indexing: { deny: ['*'] } });

tests/integration/documents/collections/options.test.ts

@@ -15,7 +15,7 @@
 import { DEFAULT_COLLECTION_NAME, it, parallel } from '@/tests/testlib';
 import assert from 'assert';
 
-parallel('integration.documents.collections.options', { dropEphemeral: 'colls:after' }, ({ db }) => {
+parallel('integration.documents.collections.options', { drop: 'colls:after' }, ({ db }) => {
   it('lists its own options', async () => {
     const coll = db.collection(DEFAULT_COLLECTION_NAME);
     const res = await coll.options();

tests/integration/documents/ids.test.ts

@@ -17,7 +17,7 @@ import assert from 'assert';
 import { ObjectId, UUID } from '@/src/documents';
 import { useSuiteResources, DEFAULT_COLLECTION_NAME, it, parallel } from '@/tests/testlib';
 
-parallel('(LONG) integration.documents.ids', { dropEphemeral: 'colls:after' }, ({ db }) => {
+parallel('(LONG) integration.documents.ids', { drop: 'colls:after' }, ({ db }) => {
   const collections = useSuiteResources(() => ({
     default: db.collection(DEFAULT_COLLECTION_NAME).deleteMany({}).then(_ => db.collection(DEFAULT_COLLECTION_NAME)),
     uuid: db.createCollection(`${DEFAULT_COLLECTION_NAME}_uuid`, { defaultId: { type: 'uuid' } }),

tests/integration/documents/tables/cursor.test.ts

@@ -16,11 +16,12 @@
 import { DataAPIVector, SomeDoc } from '@/src/documents';
 import {
   DEFAULT_TABLE_NAME,
-  parallel, EverythingTableSchema,
+  describe,
+  EverythingTableSchema,
   initCollectionWithFailingClient,
   it,
   OTHER_KEYSPACE,
-  describe,
+  parallel,
 } from '@/tests/testlib';
 import assert from 'assert';
 
@@ -90,7 +91,7 @@ describe('integration.documents.table.cursor', { truncate: 'tables:before' }, ({
 
       assert.ok(doc, 'Doc is not the 21st in the collections');
       assert.equal(cursor.state, 'started');
-      // assert.strictEqual(cursor.buffered(), 19);
+      assert.strictEqual(cursor.buffered(), 19);
     });
 
     it('should return null if there are no more documents with next()', async () => {
@@ -251,7 +252,7 @@ describe('integration.documents.table.cursor', { truncate: 'tables:before' }, ({
     });
 
     it('should return sort vector on only first API call if includeSortVector: true', async () => {
-      const cursor = table_.find({}).sort({ vector: [1, 1, 1, 1, 1] }).includeSortVector();
+      const cursor = table.find({}).sort({ vector: [1, 1, 1, 1, 1] }).includeSortVector();
       const start1 = performance.now();
       assert.deepStrictEqual(await cursor.getSortVector(), [1, 1, 1, 1, 1]);
       assert.ok(performance.now() - start1 > 5);
@@ -267,7 +268,7 @@ describe('integration.documents.table.cursor', { truncate: 'tables:before' }, ({
     });
 
     it('should return null in getSortVector if includeSortVector: false', async () => {
-      const cursor = table_.find({}).sort({ vector: [1, 1, 1, 1, 1] });
+      const cursor = table.find({}).sort({ vector: [1, 1, 1, 1, 1] });
       await cursor.hasNext();
       assert.deepStrictEqual(await cursor.getSortVector(), null);
     });

tests/integration/documents/tables/delete-one.test.ts

@@ -0,0 +1,48 @@
+// Copyright DataStax, Inc.
+//
+// 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.
+// noinspection DuplicatedCode
+
+import { DataAPIResponseError } from '@/src/documents';
+import { it, parallel } from '@/tests/testlib';
+import assert from 'assert';
+
+parallel('integration.documents.tables.delete-one', { truncate: 'colls:before' }, ({ table }) => {
+  it('should error on sort being set', async (key) => {
+    await assert.rejects(() => table.deleteOne({ text: key, int: 0 }, { sort: { int: 1 } }), DataAPIResponseError);
+    await assert.rejects(() => table.deleteOne({ text: key, int: 0 }, { sort: { vector: [.1, .2, .3, .4, .5] } }), DataAPIResponseError);
+  });
+
+  it('should delete one document with various filters', async (key1, key2) => {
+    await table.insertOne({ text: key1, int: 0 });
+    await table.deleteOne({ text: key1, int: { $gt: 0 } });
+    assert.deepStrictEqual((await table.findOne({ text: key1, int: 0 }))?.int, 0);
+
+    await table.insertOne({ text: key2, int: 1 });
+    await table.deleteOne({ text: key2, int: { $gt: 0 } });
+    assert.deepStrictEqual(await table.findOne({ text: key2, int: 1 }), null);
+  });
+
+  it('should delete many documents with $ne', async (key) => {
+    await table.insertMany(Array.from({ length: 10 }, (_, i) => ({ text: key, int: i })));
+    await table.deleteOne({ text: key, int: { $ne: 5 } });
+
+    for (let i = 0; i < 10; i++) {
+      if (i === 5) {
+        assert.deepStrictEqual(await table.findOne({ text: key, int: i }, { projection: { text: 1, int: 1 } }), { text: key, int: i });
+      } else {
+        assert.deepStrictEqual(await table.findOne({ text: key, int: i }), null);
+      }
+    }
+  });
+});

tests/integration/documents/tables/find-one.test.ts

@@ -27,7 +27,7 @@ import { EverythingTableSchema, it, parallel } from '@/tests/testlib';
 import assert from 'assert';
 import BigNumber from 'bignumber.js';
 
-parallel('integration.documents.tables.find-one', { truncate: 'colls:before' }, ({ table }) => {
+parallel('integration.documents.tables.find-one', { truncate: 'colls:before', drop: 'tables:after' }, ({ table }) => {
   it('should find one partial row', async (key) => {
     const uuid = UUID.v4();