datastore-api 4.0.0 → 4.0.3

package/src/lib/dstore-api-cloud.spec.ts

@@ -5,26 +5,26 @@
  * Copyright (c) 2021, 2023 Dr. Maximilian Dornseif
  */
 // @ts-nocheck
-import { Datastore, Key } from '@google-cloud/datastore'
-import { assert, describe, expect, test } from 'vitest'
+import { Datastore, Key } from '@google-cloud/datastore';
+import { assert, describe, expect, test } from 'vitest';
 
-import { Dstore } from './dstore-api'
+import { Dstore } from './dstore-api';
 
 function getDstore() {
-  return new Dstore(new Datastore({ namespace: 'test', projectId: 'hdmashup-hrd' }))
+  return new Dstore(new Datastore({ namespace: 'test', projectId: 'hdmashup-hrd' }));
 }
 
 test('keySerialize', async () => {
-  const kvStore = getDstore()
-  assert.deepEqual(kvStore.key(['testYodel', 123]).path, ['testYodel', 123])
+  const kvStore = getDstore();
+  assert.deepEqual(kvStore.key(['testYodel', 123]).path, ['testYodel', 123]);
   assert.deepEqual(JSON.parse(JSON.stringify(kvStore.key(['testYodel', 123]))), {
     id: 123 as any, // typing in inconclusive here
     kind: 'testYodel',
     namespace: 'test',
     path: ['testYodel', 123],
-  } as any)
-  const ser = kvStore.keySerialize(kvStore.key(['testYodel', 123]))
-  expect(ser).toMatchInlineSnapshot('"agByDwsSCXRlc3RZb2RlbBh7DKIBBHRlc3Q"')
+  } as any);
+  const ser = kvStore.keySerialize(kvStore.key(['testYodel', 123]));
+  expect(ser).toMatchInlineSnapshot('"agByDwsSCXRlc3RZb2RlbBh7DKIBBHRlc3Q"');
   expect(JSON.parse(JSON.stringify(kvStore.keyFromSerialized(ser)))).toMatchInlineSnapshot(`
     {
       "id": "123",
@@ -35,39 +35,39 @@ test('keySerialize', async () => {
         "123",
       ],
     }
-  `)
-})
+  `);
+});
 
 describe('Allocation', () => {
   test('allocateIds', async () => {
-    const kvStore = getDstore()
-    const keys = await kvStore.datastore.allocateIds(kvStore.datastore.key(['testYodel']), 2)
-    expect(Array.isArray(keys)).toBeTruthy()
-    expect(keys[0].length).toBe(2)
-    expect(keys[0][0].kind).toBe('testYodel')
-    expect(keys[0][0].id).toMatch(/\d+/)
-    expect(keys?.[1]?.keys?.length).toBe(2)
-    expect(keys[1].keys[0].partitionId.namespaceId).toMatchInlineSnapshot('"test"')
-    expect(keys[1].keys[0].path[0].idType).toMatchInlineSnapshot('"id"')
-    expect(keys[1].keys[0].path[0].kind).toMatchInlineSnapshot('"testYodel"')
-  })
+    const kvStore = getDstore();
+    const keys = await kvStore.datastore.allocateIds(kvStore.datastore.key(['testYodel']), 2);
+    expect(Array.isArray(keys)).toBeTruthy();
+    expect(keys[0].length).toBe(2);
+    expect(keys[0][0].kind).toBe('testYodel');
+    expect(keys[0][0].id).toMatch(/\d+/);
+    expect(keys?.[1]?.keys?.length).toBe(2);
+    expect(keys[1].keys[0].partitionId.namespaceId).toMatchInlineSnapshot('"test"');
+    expect(keys[1].keys[0].path[0].idType).toMatchInlineSnapshot('"id"');
+    expect(keys[1].keys[0].path[0].kind).toMatchInlineSnapshot('"testYodel"');
+  });
 
   test('allocateOneId', async () => {
-    const kvStore = getDstore()
-    const id = await kvStore.allocateOneId()
-    expect(id).toMatch(/\d+/)
-  })
-})
+    const kvStore = getDstore();
+    const id = await kvStore.allocateOneId();
+    expect(id).toMatch(/\d+/);
+  });
+});
 
 describe('Read', () => {
   test('get num_id', async () => {
-    const kvStore = getDstore()
-    const entity = { key: kvStore.key(['testYodel', 2]), data: { foo: 'bar' } }
+    const kvStore = getDstore();
+    const entity = { key: kvStore.key(['testYodel', 2]), data: { foo: 'bar' } };
     const entity2 = {
       key: kvStore.key(['testYodel', 3]),
       data: { foo: 'bar' },
-    }
-    const commitResponse = await kvStore.save([entity, entity2])
+    };
+    const commitResponse = await kvStore.save([entity, entity2]);
     // expect(isNumber(commitResponse?.[0]?.indexUpdates)).toBeTruthy();
     // expect(commitResponse).toMatchInlineSnapshot(`
     //   Array [
@@ -109,22 +109,22 @@ describe('Read', () => {
           ],
         },
       }
-    `)
+    `);
 
-    const result = await kvStore.get(entity.key)
+    const result = await kvStore.get(entity.key);
     // get returns a single Entity
-    expect(Array.isArray(result)).toBeFalsy()
-    expect(result).toMatchInlineSnapshot('null')
+    expect(Array.isArray(result)).toBeFalsy();
+    expect(result).toMatchInlineSnapshot('null');
     // expect(kvStore.readKey(result)).toBeInstanceOf(Key);
 
-    const result2 = await kvStore.getMulti([entity.key])
+    const result2 = await kvStore.getMulti([entity.key]);
     // getMulti returns a Array even for single keys
     expect(result2).toMatchInlineSnapshot(`
       [
         null,
       ]
-    `)
-    const result3 = await kvStore.getMulti([entity.key, kvStore.key(['testYodel', 3])])
+    `);
+    const result3 = await kvStore.getMulti([entity.key, kvStore.key(['testYodel', 3])]);
     // getMulti returns a Array with multiple keys
     // expect(Array.isArray(result)).toBeTruthy();
     expect(result3).toMatchInlineSnapshot(`
@@ -132,8 +132,8 @@ describe('Read', () => {
         null,
         null,
       ]
-    `)
-    const result4 = await kvStore.getMulti([entity.key, entity.key])
+    `);
+    const result4 = await kvStore.getMulti([entity.key, entity.key]);
     // getMulti returns a Array but collapses duplicate keys
     // expect(Array.isArray(result)).toBeTruthy();
     // Firestore in Datastore returns the entity once
@@ -144,9 +144,9 @@ describe('Read', () => {
         null,
         null,
       ]
-    `)
+    `);
 
-    const result5 = await kvStore.getMulti([entity.key, kvStore.key(['YodelNotThere', 3])])
+    const result5 = await kvStore.getMulti([entity.key, kvStore.key(['YodelNotThere', 3])]);
     // getMulti returns a Array but omits unknown keys
     // expect(Array.isArray(result)).toBeTruthy();
     expect(result5).toMatchInlineSnapshot(`
@@ -154,39 +154,39 @@ describe('Read', () => {
         null,
         null,
       ]
-    `)
-    const result6 = await kvStore.getMulti([])
+    `);
+    const result6 = await kvStore.getMulti([]);
     // getMulti returns a empty Array for an empty array
     // expect(Array.isArray(result)).toBeTruthy();
-    expect(result6).toMatchInlineSnapshot('[]')
-  })
-})
+    expect(result6).toMatchInlineSnapshot('[]');
+  });
+});
 
 test('get name', async (t) => {
-  const kvStore = getDstore()
+  const kvStore = getDstore();
   const entity = {
     key: kvStore.key(['testYodel', 'two']),
     data: { foo: 'bar' },
-  }
-  await kvStore.save([entity])
-  const result = await kvStore.get(entity.key)
-  expect(result?._keyStr).toMatchInlineSnapshot('"agByEgsSCXRlc3RZb2RlbCIDdHdvDKIBBHRlc3Q"')
-  expect(result?.foo).toBe('bar')
-})
+  };
+  await kvStore.save([entity]);
+  const result = await kvStore.get(entity.key);
+  expect(result?._keyStr).toMatchInlineSnapshot('"agByEgsSCXRlc3RZb2RlbCIDdHdvDKIBBHRlc3Q"');
+  expect(result?.foo).toBe('bar');
+});
 
 describe('query', async () => {
   test('raw', async () => {
-    const kvStore = getDstore()
+    const kvStore = getDstore();
     const entity = {
       key: kvStore.key(['testYodel', '3']),
       data: { foo: 'bar', baz: 'baz' },
-    }
+    };
 
-    await kvStore.save([entity])
-    const query = kvStore.datastore.createQuery('testYodel')
-    query.limit(1)
-    const [entities, runQueryInfo] = await kvStore.datastore.runQuery(query)
-    expect(entities.length).toBe(1)
+    await kvStore.save([entity]);
+    const query = kvStore.datastore.createQuery('testYodel');
+    query.limit(1);
+    const [entities, runQueryInfo] = await kvStore.datastore.runQuery(query);
+    expect(entities.length).toBe(1);
     expect(entities).toMatchInlineSnapshot(`
       [
         {
@@ -202,18 +202,18 @@ describe('query', async () => {
           },
         },
       ]
-    `)
-  })
+    `);
+  });
 
   test('query', async () => {
-    const kvStore = getDstore()
+    const kvStore = getDstore();
     const entity = {
       key: kvStore.key(['testYodel', '3']),
       data: { foo: 'bar', baz: 'baz' },
-    }
+    };
 
-    const saveResult = await kvStore.save([entity])
-    expect(saveResult?.[0]?.mutationResults?.key).toMatchInlineSnapshot('undefined')
+    const saveResult = await kvStore.save([entity]);
+    expect(saveResult?.[0]?.mutationResults?.key).toMatchInlineSnapshot('undefined');
 
     // expect(saveResult).toMatchInlineSnapshot(`
     //   [
@@ -253,13 +253,13 @@ describe('query', async () => {
           ],
         },
       }
-    `)
+    `);
     // Give Datastore time to become consistent
-    do {} while ((await kvStore.get(entity.key)) === null)
+    do {} while ((await kvStore.get(entity.key)) === null);
 
-    const query = kvStore.createQuery('testYodel')
-    query.limit(1)
-    const [entities, runQueryInfo] = await kvStore.runQuery(query)
+    const query = kvStore.createQuery('testYodel');
+    query.limit(1);
+    const [entities, runQueryInfo] = await kvStore.runQuery(query);
     // expect(entities.length).toBe(1)
     expect(entities).toMatchInlineSnapshot(`
       [
@@ -277,112 +277,112 @@ describe('query', async () => {
           },
         },
       ]
-    `)
+    `);
     expect(runQueryInfo).toMatchInlineSnapshot(`
       {
         "endCursor": "Ci4SKGoOc35oZG1hc2h1cC1ocmRyDwsSCXRlc3RZb2RlbBgCDKIBBHRlc3QYACAA",
         "moreResults": "MORE_RESULTS_AFTER_LIMIT",
       }
-    `)
-    expect(entities?.[0]?.foo).toBe('bar')
-    expect(entities?.[0]?.[Datastore.KEY]?.kind).toBe('testYodel')
-    expect(runQueryInfo?.moreResults).toBe('MORE_RESULTS_AFTER_LIMIT')
+    `);
+    expect(entities?.[0]?.foo).toBe('bar');
+    expect(entities?.[0]?.[Datastore.KEY]?.kind).toBe('testYodel');
+    expect(runQueryInfo?.moreResults).toBe('MORE_RESULTS_AFTER_LIMIT');
 
     // modern interface
-    const [result2] = await kvStore.query('testYodel', [], 1, [], ['baz'])
-    expect(result2.length).toBe(1)
+    const [result2] = await kvStore.query('testYodel', [], 1, [], ['baz']);
+    expect(result2.length).toBe(1);
     // foo is removed by selection
     expect(JSON.parse(JSON.stringify(result2?.[0]))).toMatchInlineSnapshot(`
       {
         "_keyStr": "agByEAsSCXRlc3RZb2RlbCIBMwyiAQR0ZXN0",
         "baz": "baz",
       }
-    `)
+    `);
 
-    const key = kvStore.readKey(result2?.[0])
-    expect(key.id).toBe(entity.key.id)
-  })
-})
+    const key = kvStore.readKey(result2?.[0]);
+    expect(key.id).toBe(entity.key.id);
+  });
+});
 
 test('set', async () => {
   // expect.assertions(2);
-  const kvStore = getDstore()
+  const kvStore = getDstore();
   const result = await kvStore.set(kvStore.key(['testYodel', '5e7']), {
     foo: 'bar',
-  })
-  expect(result.name).toBe('5e7')
-  expect(result.kind).toBe('testYodel')
+  });
+  expect(result.name).toBe('5e7');
+  expect(result.kind).toBe('testYodel');
 
   // autogenerate key
-  const result2 = await kvStore.set(kvStore.key(['testYodel']), { foo: 'bar' })
-  expect(result2.kind).toBe('testYodel')
-})
+  const result2 = await kvStore.set(kvStore.key(['testYodel']), { foo: 'bar' });
+  expect(result2.kind).toBe('testYodel');
+});
 
 test('save / upsert', async () => {
   // expect.assertions(2);
-  const kvStore = getDstore()
+  const kvStore = getDstore();
   const entity = {
     key: kvStore.key(['testYodel', 3]),
     data: { foo: 'bar' } as any,
-  }
-  const result = await kvStore.save([entity])
+  };
+  const result = await kvStore.save([entity]);
   // const result2 = await kvStore.upsert([entity]);
-  expect(result?.[0]?.mutationResults?.[0]?.conflictDetected).toBe(false)
-  expect(entity.data._keyStr).toMatchInlineSnapshot('"agByDwsSCXRlc3RZb2RlbBgDDKIBBHRlc3Q"')
-  expect(entity.data.foo).toBe('bar')
-  expect(entity.data[Datastore.KEY].kind).toBe('testYodel')
-})
+  expect(result?.[0]?.mutationResults?.[0]?.conflictDetected).toBe(false);
+  expect(entity.data._keyStr).toMatchInlineSnapshot('"agByDwsSCXRlc3RZb2RlbBgDDKIBBHRlc3Q"');
+  expect(entity.data.foo).toBe('bar');
+  expect(entity.data[Datastore.KEY].kind).toBe('testYodel');
+});
 
 test('update', async (t) => {
   //     expect.assertions(3);
-  const kvStore = getDstore()
-  const keyName = `4insert${Math.random()}`
+  const kvStore = getDstore();
+  const keyName = `4insert${Math.random()}`;
   const entity = {
     key: kvStore.key(['testYodel', keyName]),
     data: { foo: 'bar' },
-  }
+  };
   // const request = kvStore.update([entity]);
   // await expect(request).rejects.toThrowError(Error);
 
-  await kvStore.save([entity])
-  const result = await kvStore.update([entity])
-  expect(result?.[0]?.mutationResults?.[0]?.conflictDetected).toBe(false)
-  expect(result?.[0]?.mutationResults?.[0]?.key).toBe(null)
+  await kvStore.save([entity]);
+  const result = await kvStore.update([entity]);
+  expect(result?.[0]?.mutationResults?.[0]?.conflictDetected).toBe(false);
+  expect(result?.[0]?.mutationResults?.[0]?.key).toBe(null);
   // expect(result?.[0]?.indexUpdates).toBe(2);
-})
+});
 
 test('insert / delete', async (t) => {
   // expect.assertions(2);
-  const kvStore = getDstore()
-  const testkey = kvStore.key(['testYodel', 4])
-  await kvStore.delete([testkey])
+  const kvStore = getDstore();
+  const testkey = kvStore.key(['testYodel', 4]);
+  await kvStore.delete([testkey]);
   const entity = {
     key: testkey,
     data: { foo: 'bar' } as any,
-  }
-  const result = await kvStore.insert([entity])
+  };
+  const result = await kvStore.insert([entity]);
 
-  expect(result?.[0]?.mutationResults?.[0]?.conflictDetected).toBe(false)
-  expect(result?.[0]?.mutationResults?.[0]?.version).toMatch(/\d+/)
-  expect(entity.data.foo).toBe('bar')
-  expect(entity.key.path[0]).toBe('testYodel')
+  expect(result?.[0]?.mutationResults?.[0]?.conflictDetected).toBe(false);
+  expect(result?.[0]?.mutationResults?.[0]?.version).toMatch(/\d+/);
+  expect(entity.data.foo).toBe('bar');
+  expect(entity.key.path[0]).toBe('testYodel');
   // expect(result?.[0]?.indexUpdates).toBe(3);
 
-  const result2 = await kvStore.delete([entity.key])
-  expect(result2?.[0]?.mutationResults?.[0]?.conflictDetected).toBe(false)
-})
+  const result2 = await kvStore.delete([entity.key]);
+  expect(result2?.[0]?.mutationResults?.[0]?.conflictDetected).toBe(false);
+});
 
 test('exception', async () => {
   // expect.assertions(2);
-  const kvStore = getDstore()
+  const kvStore = getDstore();
   try {
     const result = await kvStore.set(kvStore.key(['testYodel', NaN]), {
       foo: 'bar',
-    })
+    });
   } catch (e) {
-    expect(e.stack).toMatch(/Dstore\.set/)
+    expect(e.stack).toMatch(/Dstore\.set/);
   }
-})
+});
 // describe("Transactions", () => {
 //   it("simple", async () => {
 //     expect.assertions(2);