@cloudbase/oauth 0.1.1-alpha → 0.1.1-alpha.2

package/test/web/cases/database/date.js

@@ -0,0 +1,122 @@
+import * as assert from 'power-assert';
+import { callbackWithTryCatch, catchCallback, isSuccess } from '../../util';
+import * as util from 'util';
+import { registerCase } from '.';
+
+export function registerDate(app, collName) {
+  const db = app.database();
+  const collection = db.collection(collName);
+  // const nameList = ["f", "b", "e", "d", "a", "c"];
+
+  registerCase('database date: CRUD', async () => {
+    const date = new Date();
+    const offset = 60 * 1000;
+    const timestamp = Math.floor(Number(new Date()) / 1000);
+    const initialData = {
+      name: 'test',
+      date,
+      // eslint-disable-next-line
+      serverDate1: new db.serverDate(),
+      serverDate2: db.serverDate({ offset }),
+      timestamp: {
+        $timestamp: timestamp
+      },
+      foo: {
+        bar: db.serverDate({ offset })
+      }
+    };
+
+    await new Promise(async resolve => {
+      try {
+        // Create
+        const res = await collection.add(initialData).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.id, { res });
+        assert(isSuccess(0, res) && res.requestId, { res });
+
+        // Read
+        const { id } = res;
+        let result = await collection.where({
+          _id: id
+        }).get().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert.strictEqual(result.data[0].date.getTime(), date.getTime());
+        assert(util.isDate(result.data[0].foo.bar));
+        assert.strictEqual(assert.strictEqual(result.data[0].serverDate1.getDate(), date.getDate()));
+        assert.strictEqual(result.data[0].serverDate1.getTime() + offset, result.data[0].serverDate2.getTime());
+        assert.strictEqual(result.data[0].timestamp.getTime(), timestamp * 1000);
+
+        result = await collection.where({
+          date: db.command.eq(date)
+        }).get().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert.strictEqual(result.data[0].date.getTime(), date.getTime());
+
+        result = await collection.where({
+          date: db.command.lte(date)
+        }).get().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(result.data.length > 0);
+
+        result = await collection.where({
+          date: db.command.lte(date).and(db.command.gte(date))
+        }).get().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(result.data.length > 0);
+
+        // Update
+        const newDate = new Date();
+        // eslint-disable-next-line
+        const newServerDate = new db.serverDate({ offset: 1000 * 60 * 60 }); // offset一小时
+        result = await collection.where({
+          date: db.command.lte(date).and(db.command.gte(date))
+        }).update({
+          date: newDate,
+          serverDate2: newServerDate
+        }).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert.strictEqual(result.updated, 1);
+
+        result = await collection.where({
+          _id: id
+        }).get().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert.strictEqual(result.data[0].date.getTime(), newDate.getTime());
+        assert(result.data[0].serverDate2.getTime() - result.data[0].serverDate1.getTime() > 1000 * 60 * 60);
+
+        // Delete
+        const deleteRes = await collection.doc(id).remove().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(deleteRes.deleted === 1, { res: deleteRes });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+}

package/test/web/cases/database/db.js

@@ -0,0 +1,20 @@
+// database db
+import * as assert from 'power-assert';
+import { registerCase } from '.';
+
+export function registerDb(app, collName) {
+  const db = app.database();
+
+  registerCase('database db: get collection reference', () => {
+    const collection = db.collection(collName);
+    assert(collection.name === collName);
+  });
+
+  registerCase('database db: Error: get collection without collection name', () => {
+    try {
+      db.collection();
+    } catch (e) {
+      assert(e.message === 'Collection name is required');
+    }
+  });
+}

package/test/web/cases/database/document.js

@@ -0,0 +1,160 @@
+import * as assert from 'power-assert';
+import { callbackWithTryCatch, catchCallback, isSuccess } from '../../util';
+import { Util } from '@cloudbase/database/dist/esm/util';
+import { registerCase } from '.';
+
+export function registerDocument(app, collName) {
+  const docIDGenerated = Util.generateDocId();
+  const db = app.database();
+  const _ = db.command;
+  const collection = db.collection(collName);
+
+  registerCase('database document: docID test', () => {
+    const document = collection.doc(docIDGenerated);
+    assert(document.id === docIDGenerated);
+  });
+
+  registerCase('database document: API - set data in empty document', async () => {
+    await new Promise(async resolve => {
+      try {
+        const document = collection.doc(docIDGenerated);
+        await document.set({
+          name: 'jude'
+        }).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }));
+
+        let res = await collection.where({
+          name: _.eq('jude')
+        }).get().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && Array.isArray(res.data));
+
+        res = await collection.where({
+          name: _.eq('jude')
+        }).remove().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.deleted >= 1, { res });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+
+  registerCase('database document: API - set data in document existed', async () => {
+    await new Promise(async resolve => {
+      try {
+        let res = await collection.add({ data: 'test' }).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.id, { res });
+
+        const documents = await collection.limit(1).get().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        const docId = documents.data[0]._id;
+
+        res = await collection.doc(docId).set({
+          data: { type: 'set' }
+        }).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.updated === 1, { res });
+
+        res = await collection.doc(docId).set({
+          data: { arr: [1, 2, 3], foo: 123 },
+          array: [0, 0, 0]
+        }).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.updated === 1, { res });
+
+        res = await collection.doc(docId).update({
+          data: { arr: db.command.push([4, 5, 6]), foo: db.command.inc(1) },
+          array: db.command.pop()
+        }).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.updated === 1, { res });
+
+        res = await collection.doc(docId).remove().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.deleted >= 1, { res });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+
+  registerCase('database document: API - remove document that not exist', async () => {
+    await new Promise(async resolve => {
+      try {
+        const document = collection.doc(docIDGenerated);
+        const res = await document.remove().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && !res.deleted, { res });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+
+  registerCase('database document: API - remove document should success', async () => {
+    await new Promise(async resolve => {
+      try {
+        let res = await collection.add({ data: 'test' }).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.id, { res });
+
+        const documents = await collection.get().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        const docId = documents.data[0]._id;
+
+        res = await collection.doc(docId).remove().catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res) && res.deleted >= 1, { res });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+}

package/test/web/cases/database/geo-advanced.js

@@ -0,0 +1,327 @@
+import * as assert from 'power-assert';
+import { catchCallback, isSuccess, callbackWithTryCatch } from '../../util';
+import { registerCase } from '.';
+
+export function registerGeoAdvanced(app, collName) {
+  const db = app.database();
+  const collection = db.collection(collName);
+
+  const { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } = db.Geo;
+  function randomPoint() {
+    return new Point(180 - 360 * Math.random(), 90 - 180 * Math.random());
+  }
+
+  const geoNearPoint = new Point(0, 0);
+  const line = new LineString([randomPoint(), randomPoint()]);
+
+  // “回”字的外环
+  const point1 = new Point(-2, -2);
+  const point2 = new Point(2, -2);
+  const point3 = new Point(2, 2);
+  const point4 = new Point(-2, 2);
+  // “回”字的内环
+  const point5 = new Point(-1, -1);
+  const point6 = new Point(1, -1);
+  const point7 = new Point(1, 1);
+  const point8 = new Point(-1, 1);
+  const polygon = new Polygon([
+    new LineString([point1, point2, point3, point4, point1]),
+    new LineString([point5, point6, point7, point8, point5])
+  ]);
+
+  const multiPoint = new MultiPoint([randomPoint(), randomPoint(), randomPoint(), randomPoint()]);
+  const multiLineString = new MultiLineString([
+    new LineString([randomPoint(), randomPoint()]),
+    new LineString([randomPoint(), randomPoint()]),
+    new LineString([randomPoint(), randomPoint()]),
+    new LineString([randomPoint(), randomPoint()])
+  ]);
+  const multiPolygon = new MultiPolygon([
+    new Polygon([new LineString([point1, point2, point3, point4, point1])]),
+    new Polygon([new LineString([point5, point6, point7, point8, point5])])
+  ]);
+
+  const initialData = {
+    point: randomPoint(),
+    geoNearPoint,
+    line,
+    polygon,
+    multiPoint,
+    multiLineString,
+    multiPolygon
+  };
+
+  registerCase('database geo: GEO Advanced - CRUD', async () => {
+    await new Promise(async resolve => {
+      try {
+        // Create
+        let res = await collection.add(initialData).catch(
+          callbackWithTryCatch(
+            err => {
+              assert(false, { err });
+            },
+            () => {
+              resolve();
+            }
+          )
+        );
+        assert(isSuccess(0, res) && res.id, { res });
+        assert(isSuccess(0, res) && res.requestId, { res });
+
+        // Read
+        const readRes = await collection
+          .where({
+            _id: res.id
+          })
+          .get()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, readRes) && readRes.data.length > 0, { readRes });
+        const data = readRes.data[0];
+
+        assert(data.point instanceof Point);
+        assert(data.line instanceof LineString);
+        assert(data.polygon instanceof Polygon);
+        assert(data.multiPoint instanceof MultiPoint);
+        assert(data.multiLineString instanceof MultiLineString);
+        assert(data.multiPolygon instanceof MultiPolygon);
+
+        assert.deepStrictEqual(data.point, initialData.point);
+        assert.deepStrictEqual(data.line, line);
+        assert.deepStrictEqual(data.polygon, polygon);
+        assert.deepStrictEqual(data.multiPoint, multiPoint);
+        assert.deepStrictEqual(data.multiLineString, multiLineString);
+        assert.deepStrictEqual(data.multiPolygon, multiPolygon);
+
+        // Update
+        let result = await collection
+          .doc(res.id)
+          .set(initialData)
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, result) && result.requestId, { result });
+        assert.strictEqual(result.updated, 1);
+
+        // Delete
+        const deleteRes = await collection
+          .where({
+            _id: res.id
+          })
+          .remove()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, deleteRes) && deleteRes.deleted >= 1, { deleteRes });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+
+  registerCase('database geo: GEO - bad create', async () => {
+    await new Promise(async resolve => {
+      try {
+        // bad Point
+        assert.throws(() => new Point());
+        assert.throws(() => new Point([], {}));
+
+        // bad LineString
+        assert.throws(() => new LineString({}));
+        assert.throws(() => new LineString([]));
+        assert.throws(() => new LineString([123, []]));
+
+        // bad Polygon
+        assert.throws(() => new Polygon(null));
+        assert.throws(() => new Polygon([]));
+        assert.throws(() => new Polygon([666, 789]));
+        assert.throws(
+          () => new Polygon([new LineString([point1, point2, point3, point4, point8])])
+        );
+
+        // bad MultiPoint
+        assert.throws(() => new MultiPoint({}));
+        assert.throws(() => new MultiPoint([]));
+        assert.throws(() => new MultiPoint([{}, {}]));
+
+        // bad MultiLineString
+        assert.throws(() => new MultiLineString({}));
+        assert.throws(() => new MultiLineString([]));
+        assert.throws(() => new MultiLineString([123, null]));
+
+        // bad MultiPolygon
+        assert.throws(() => new MultiPolygon(123));
+        assert.throws(() => new MultiPolygon([]));
+        assert.throws(() => new MultiPolygon([666, 666]));
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+
+  registerCase('database geo: GEO - geoNear', async () => {
+    await new Promise(async resolve => {
+      try {
+        // Create
+        const geoPoint = new Point(22, 33);
+        const res = await collection
+          .add({
+            ...initialData,
+            point: geoPoint
+          })
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, res) && res.id, { res });
+        assert(res.requestId);
+
+        // Read
+        const readRes = await collection
+          .where({
+            point: db.command.geoNear({
+              geometry: geoPoint,
+              maxDistance: 1,
+              minDistance: 0
+            })
+          })
+          .get()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, readRes) && readRes.data.length > 0, { readRes });
+        assert.deepStrictEqual(readRes.data[0].point, geoPoint);
+
+        // Delete
+        const deleteRes = await collection
+          .where({
+            _id: res.id
+          })
+          .remove()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, deleteRes) && deleteRes.deleted >= 1, { deleteRes });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+
+  registerCase('database geo: GEO - geoWithin', async () => {
+    await new Promise(async resolve => {
+      try {
+        // Create
+        const res = await collection
+          .add({
+            ...initialData,
+            point: new Point(0, 0)
+          })
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, res) && res.id, { res });
+
+        // Read
+        const readRes = await collection
+          .where({
+            point: db.command.geoWithin({
+              geometry: new Polygon([new LineString([point1, point2, point3, point4, point1])])
+            })
+          })
+          .get()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, readRes) && readRes.data.length > 0, { readRes });
+        assert.deepStrictEqual(readRes.data[0].point, new Point(0, 0));
+
+        // Delete
+        const deleteRes = await collection
+          .where({
+            point: db.command.geoWithin({
+              geometry: new Polygon([new LineString([point1, point2, point3, point4, point1])])
+            })
+          })
+          .remove()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, deleteRes) && deleteRes.deleted >= 1, { deleteRes });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+}