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

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

@@ -0,0 +1,105 @@
+// database geo
+import * as assert from 'power-assert';
+import { catchCallback, isSuccess, callbackWithTryCatch } from '../../util';
+import { registerCase } from '.';
+
+export function registerGeo(app, collName) {
+  const db = app.database();
+  const collection = db.collection(collName);
+  // const nameList = ["f", "b", "e", "d", "a", "c"];
+
+  const longitude = -180;
+  const latitude = 20;
+  const point = new db.Geo.Point(longitude, latitude);
+  const initialData = {
+    point,
+    pointArr: [point, point, point],
+    uuid: '416a4700-e0d3-11e8-911a-8888888888',
+    string: '新增单个string字段1。新增单个string字段1。',
+    due: new Date('2018-09-01'),
+    int: 100,
+    geo: new db.Geo.Point(90, 23),
+    array: [
+      {
+        string: '99999999',
+        due: new Date('2018-09-01'),
+        geo: new db.Geo.Point(90, 23),
+      },
+      {
+        string: '0000000',
+        geo: new db.Geo.Point(90, 23),
+        null: null,
+      }
+    ],
+  };
+  registerCase('database geo: GEO Point - 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 });
+
+        const res2 = await collection.doc(res.id).set(initialData).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+        assert(isSuccess(0, res2) && res2.updated >= 1, { res: res2 });
+
+        // Read
+        let result = await collection
+          .where({
+            _id: res.id
+          })
+          .get().catch(callbackWithTryCatch(err => {
+            assert(false, { err });
+          }, () => {
+            resolve();
+          }));
+        assert(isSuccess(0, result) && result.data.length > 0, { res: result });
+        assert.deepEqual(result.data[0].point, { longitude, latitude });
+
+        // TODO: 现在对 GEO 进行 $eq 操作，小概率会查不到，需要修改查询的底层结构
+        // result = await collection
+        //     .where({
+        //         point: db.command.eq(point)
+        //     })
+        //     .get();
+        // console.log(point, result);
+        // assert(result.data.length > 0);
+
+        // result = await collection
+        //     .where({
+        //         point: db.command.or(db.command.eq(point))
+        //     })
+        //     .get();
+        // console.log(point, result);
+        // assert(result.data.length > 0);
+
+        // result = await collection
+        //     .where({
+        //         point: point
+        //     })
+        //     .get();
+        // console.log(result);
+        // assert(result.data.length > 0);
+
+        // Delete
+        const deleteRes = await collection
+          .where({
+            _id: res.id
+          })
+          .remove();
+        assert(isSuccess(0, deleteRes) && deleteRes.deleted === 1, { res: deleteRes });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+}

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

@@ -0,0 +1,315 @@
+// database
+import * as assert from 'power-assert';
+
+import {
+  register,
+  isSuccess,
+  catchCallback,
+  callbackWithTryCatch
+} from '../../util';
+
+import { registerCollection } from './collection';
+import { registerCommand } from './command';
+import { registerDate } from './date';
+import { registerDb } from './db';
+import { registerDocument } from './document';
+import { registerGeo } from './geo';
+import { registerGeoAdvanced } from './geo-advanced';
+import { registerOrder } from './order';
+import { registerRegex } from './regex';
+import { registerRealtime } from './realtime';
+
+export function registerCase(msg,fn){
+  register('database',msg,fn);
+}
+
+export async function registerDatabaseCases(app) {
+  const collName = 'coll-1';
+
+  registerCollection(app, collName);
+  registerCommand(app, collName);
+  registerDate(app, collName);
+  registerDb(app, collName);
+  registerDocument(app, collName);
+  registerGeo(app, collName);
+  registerGeoAdvanced(app, collName);
+  registerOrder(app, collName);
+  registerRegex(app, collName);
+  registerRealtime(app, collName);
+
+  registerCase('Document - CRUD', async () => {
+    // await new Promise(async resolve => {
+    //   try {
+        const db = app.database();
+        const _ = db.command;
+        const collection = db.collection(collName);
+        const initialData = {
+          name: 'aaa',
+          array: [
+            1,
+            2,
+            3,
+            [4, 5, 6],
+            { a: 1, b: { c: 'fjasklfljkas', d: false }}
+          ],
+          data: {
+            a: 'a',
+            b: 'b',
+            c: 'c'
+          },
+          null: null,
+          deepObject: {
+            'l-02-01': {
+              'l-03-01': {
+                'l-04-01': {
+                  level: 1,
+                  name: 'l-01',
+                  flag: '0'
+                }
+              }
+            }
+          }
+        };
+
+        // Create
+        let res = await collection.add(initialData).catch(
+          callbackWithTryCatch(
+            err => {
+              assert(false, { err });
+            },
+            () => {
+              resolve();
+            }
+          )
+        );
+        assert(isSuccess(0, res) && res.id, { res });
+
+        // Read
+        const { id } = res;
+        res = await collection
+          .where({
+            _id: id
+          })
+          .get()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert.deepStrictEqual(res.data[0].name, initialData.name, { res });
+        assert.deepStrictEqual(res.data[0].array, initialData.array, { res });
+        assert.deepStrictEqual(res.data[0].deepObject, initialData.deepObject, {
+          res
+        });
+
+        res = await collection
+          .where({
+            null: _.or(_.eq(null))
+          })
+          .get()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(res.data.length > 0);
+
+        const doc = await collection
+          .doc(id)
+          .get()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert.deepStrictEqual(doc.data[0].name, initialData.name, { res });
+        assert.deepStrictEqual(doc.data[0].array, initialData.array, { res });
+        assert.deepStrictEqual(doc.data[0].deepObject, initialData.deepObject, {
+          res
+        });
+
+        // Update
+        res = await collection
+          .where({
+            _id: id
+          })
+          .update({
+            name: 'bbb',
+            array: [{ a: 1, b: 2, c: 3 }]
+          })
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(res.updated > 0, { res });
+
+        res = await collection
+          .where({
+            _id: id
+          })
+          .update({
+            data: { a: null, b: null, c: null }
+          })
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(res.updated > 0, { res });
+
+        res = await collection
+          .where({ _id: id })
+          .get()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(res.data[0], { res });
+        assert.deepStrictEqual(
+          res.data[0].data,
+          { a: null, b: null, c: null },
+          { res }
+        );
+
+        // 数组变为对象，mongo会报错
+        res = await collection
+          .where({
+            _id: id
+          })
+          .update({
+            array: { foo: 'bar' }
+          })
+        assert.strictEqual(res.code, 'DATABASE_REQUEST_FAILED', { res });
+
+        res = await collection
+          .where({
+            _id: id
+          })
+          .get()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert.deepStrictEqual(res.data[0].array, [{ a: 1, b: 2, c: 3 }], {
+          res
+        });
+
+        // Delete
+        const deleteRes = await collection
+          .doc(id)
+          .remove()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert.strictEqual(deleteRes.deleted, 1, { res });
+    //   } catch (e) {
+    //     catchCallback(e);
+    //   } finally {
+    //     resolve();
+    //   }
+    // });
+  });
+
+  registerCase('Document - query', async () => {
+    await new Promise(async resolve => {
+      try {
+        const db = app.database();
+        const _ = db.command;
+        const collection = db.collection(collName);
+
+        // Query
+        await Promise.all([
+          collection.add({ a: 1, b: 100 }).catch(
+            callbackWithTryCatch(err => {
+              assert(false, { err });
+            })
+          ),
+          collection.add({ a: 10, b: 1 }).catch(
+            callbackWithTryCatch(err => {
+              assert(false, { err });
+            })
+          )
+        ]);
+
+        const query = _.or([
+          { b: _.and(_.gte(1), _.lte(10)) },
+          { b: _.and(_.gt(99), _.lte(101)) }
+        ]);
+        let res = await collection
+          .where(query)
+          .get()
+          .catch(
+            callbackWithTryCatch(err => {
+              assert(false, { err });
+            })
+          );
+        assert(isSuccess(0, res) && res.data.length >= 2, { res });
+
+        // Delete
+        res = await collection
+          .where(query)
+          .remove()
+          .catch(
+            callbackWithTryCatch(
+              err => {
+                assert(false, { err });
+              },
+              () => {
+                resolve();
+              }
+            )
+          );
+        assert(isSuccess(0, res) && res.deleted === 2, { res });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+}

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

@@ -0,0 +1,83 @@
+// database order
+import * as assert from 'power-assert';
+import { catchCallback, isSuccess, callbackWithTryCatch } from '../../util';
+import { registerCase } from '.';
+
+export function registerOrder(app, collName) {
+  const db = app.database();
+  const collection = db.collection(collName);
+  // const nameList = ["f", "b", "e", "d", "a", "c"];
+
+  registerCase('database order: Document - OrderBy', async () => {
+    await new Promise(async resolve => {
+      try {
+        // Create
+        for (let i = 0; i < 7; i++) {
+          const res = await collection.add({
+            category: '类别B',
+            value: Math.random()
+          }).catch(callbackWithTryCatch(err => {
+            assert(false, { err });
+          }, () => {
+            resolve();
+          }));
+          assert(isSuccess(0, res) && res.id, { res });
+        }
+
+        for (let i = 0; i < 3; i++) {
+          const res = await collection.add({
+            category: '类别C',
+            value: Math.random()
+          }).catch(callbackWithTryCatch(err => {
+            assert(false, { err });
+          }, () => {
+            resolve();
+          }));
+          assert(isSuccess(0, res) && res.id, { res });
+        }
+
+        await collection.add({
+          category: '类别A',
+          value: Math.random()
+        }).catch(callbackWithTryCatch(err => {
+          assert(false, { err });
+        }, () => {
+          resolve();
+        }));
+
+        // Read
+        let result = await collection
+          .where({
+            category: /^类别/i
+          })
+          .orderBy('category', 'asc')
+          .get().catch(callbackWithTryCatch(err => {
+            assert(false, { err });
+          }, () => {
+            resolve();
+          }));
+        assert(isSuccess(0, result) && result.data.length >= 11, { res: result });
+        assert(isSuccess(0, result) && result.data[0].category === '类别A', { res: result });
+        assert(isSuccess(0, result) && result.data[result.data.length - 1].category === '类别C', { res: result });
+
+        // Delete
+        const deleteRes = await collection
+          .where({
+            category: db.RegExp({
+              regexp: '^类别'
+            })
+          })
+          .remove().catch(callbackWithTryCatch(err => {
+            assert(false, { err });
+          }, () => {
+            resolve();
+          }));
+        assert(isSuccess(0, deleteRes) && deleteRes.deleted >= 11, { res: deleteRes });
+      } catch (e) {
+        catchCallback(e);
+      } finally {
+        resolve();
+      }
+    });
+  });
+}

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

@@ -0,0 +1,102 @@
+import * as assert from 'power-assert';
+import { isSuccess } from '../../util';
+import { registerCase } from '.';
+
+export function registerRealtime(app, collName) {
+  const db = app.database();
+
+  const _ = db.command;
+
+  // collName = "coll-1"
+  const collection = db.collection(collName);
+
+  const nextEventNum = 2;
+
+  let ref;
+
+  // auth
+  registerCase('database realtime: data ready first', async () => {
+    await collection.add({ test: 2 });
+    await collection.add({ test: 4 });
+    document.getElementById('mockAddDoc').onclick = async function() {
+      // mock新增数据
+      let calNum = nextEventNum;
+      while (calNum--) {
+        let res = await collection.add({ test: 10 });
+        console.log(res);
+        assert(res.id);
+      }
+    };
+  });
+
+  // 关闭监听
+  registerCase('database realtime: close watch', async () => {
+    ref && ref.close();
+  });
+
+  // 测试doc().watch()
+  registerCase('database realtime: one doc watch', async () => {
+    const res = await collection.get();
+    const watchDocId = res.data[0]._id;
+    collection.doc(watchDocId).watch({
+      onChange: snapshot => {
+        console.log('收到single doc snapshot**********', snapshot);
+        assert(isSuccess(0, snapshot) && snapshot.docs.length, { snapshot });
+
+        collection.doc(watchDocId).update({
+          test: 20
+        });
+      },
+      onError: error => {
+        console.log('收到single doc error**********', error);
+      }
+    });
+  });
+
+  // 多个监听
+  registerCase('database realtime: one watch init', () => {
+    // const collection = db.collection(collName)
+    let watchNum = 100;
+    const calWatchNum = 100;
+    let initOkNum = 0;
+    let nextOkObj = {};
+
+    // 开启多个监听 测试所有监听是否收到initevent 及 nextevent
+    while (watchNum--) {
+      nextOkObj[watchNum] = 0;
+      /* eslint-disable */
+      (function(watchNum) {
+        collection.where({ test: _.gt(0) }).watch({
+          onChange: snapshot => {
+            if (snapshot.msgType === 'INIT_EVENT') {
+              assert(snapshot.docChanges.length > 0);
+
+              // console.log(`收到init snapshot${watchNum}**********`, snapshot)
+
+              if (++initOkNum === calWatchNum) {
+                console.log('init snapshot all receive');
+              }
+              // 生成nextevent
+
+              // collection.add({ test: 2 })
+            }
+
+            if (snapshot.msgType === 'NEXT_EVENT') {
+              nextOkObj[watchNum]++;
+
+              if (nextOkObj[watchNum] === nextEventNum) {
+                console.log('next snapshot all receive');
+              }
+
+              assert(snapshot.docChanges.length > 0);
+              // console.log(`收到next snapshot${watchNum}**********`, snapshot)
+            }
+          },
+          onError: error => {
+            console.log('收到error1**********', error);
+          }
+        });
+      })(watchNum);
+    }
+  });
+}