Progres towards moving mongo logic into its adapter

2016-04-05 21:16:39 -07:00
parent cbbd66964a
commit 91ace4e718
9 changed files with 387 additions and 271 deletions
--- a/spec/AdaptableController.spec.js
+++ b/spec/AdaptableController.spec.js
@@ -10,7 +10,7 @@ MockController.prototype = Object.create(AdaptableController.prototype);
 MockController.prototype.constructor = AdaptableController;

 describe("AdaptableController", ()=>{
-  
+
  it("should use the provided adapter", (done) => {
    var adapter = new FilesAdapter();
    var controller = new FilesController(adapter);
@@ -22,7 +22,7 @@ describe("AdaptableController", ()=>{
    expect(controller.adapter).toBe(adapter);
    done();
  });
-  
+
  it("should throw when creating a new mock controller", (done) => {
    var adapter = new FilesAdapter();
    expect(() => {
@@ -30,7 +30,7 @@ describe("AdaptableController", ()=>{
    }).toThrow();
    done();
  });
-  
+
  it("should fail setting the wrong adapter to the controller", (done) => {
    function WrongAdapter() {};
    var adapter = new FilesAdapter();
@@ -41,7 +41,7 @@ describe("AdaptableController", ()=>{
    }).toThrow();
    done();
  });
-  
+
  it("should fail to instantiate a controller with wrong adapter", (done) => {
    function WrongAdapter() {};
    var adapter = new WrongAdapter();
@@ -50,14 +50,14 @@ describe("AdaptableController", ()=>{
    }).toThrow();
    done();
  });
-  
+
  it("should fail to instantiate a controller without an adapter", (done) => {
    expect(() => {
      new FilesController();
    }).toThrow();
    done();
  });
-  
+
  it("should accept an object adapter", (done) => {
    var adapter = {
      createFile: function(config, filename, data) { },
@@ -70,18 +70,18 @@ describe("AdaptableController", ()=>{
    }).not.toThrow();
    done();
  });
-  
+
  it("should accept an object adapter", (done) => {
    function AGoodAdapter() {};
    AGoodAdapter.prototype.createFile = function(config, filename, data) { };
    AGoodAdapter.prototype.deleteFile = function(config, filename) { };
    AGoodAdapter.prototype.getFileData = function(config, filename) { };
    AGoodAdapter.prototype.getFileLocation = function(config, filename) { };
-    
+
    var adapter = new AGoodAdapter();
    expect(() => {
      new FilesController(adapter);
    }).not.toThrow();
    done();
  });
-});
+});
--- a/spec/MongoSchemaCollectionAdapter.spec.js
+++ b/spec/MongoSchemaCollectionAdapter.spec.js
@@ -0,0 +1,55 @@
+'use strict';
+
+const MongoSchemaCollection = require('../src/Adapters/Storage/Mongo/MongoSchemaCollection').default;
+
+describe('MongoSchemaCollection', () => {
+  it('can transform legacy _client_permissions keys to parse format', done => {
+    expect(MongoSchemaCollection._TESTmongoSchemaToParseSchema({
+      "_id":"_Installation",
+      "_client_permissions":{
+        "get":true,
+        "find":true,
+        "update":true,
+        "create":true,
+        "delete":true,
+      },
+      "_metadata":{
+        "class_permissions":{
+          "get":{"*":true},
+          "find":{"*":true},
+          "update":{"*":true},
+          "create":{"*":true},
+          "delete":{"*":true},
+          "addField":{"*":true},
+        }
+      },
+      "installationId":"string",
+      "deviceToken":"string",
+      "deviceType":"string",
+      "channels":"array",
+      "user":"*_User",
+    })).toEqual({
+      className: '_Installation',
+      fields: {
+        installationId: { type: 'String' },
+        deviceToken: { type: 'String' },
+        deviceType: { type: 'String' },
+        channels: { type: 'Array' },
+        user: { type: 'Pointer', targetClass: '_User' },
+        ACL: { type: 'ACL' },
+        createdAt: { type: 'Date' },
+        updatedAt: { type: 'Date' },
+        objectId: { type: 'String' },
+      },
+      classLevelPermissions: {
+        find: { '*': true },
+        get: { '*': true },
+        create: { '*': true },
+        update: { '*': true },
+        delete: { '*': true },
+        addField: { '*': true },
+      }
+    });
+    done();
+  });
+});
--- a/spec/OAuth.spec.js
+++ b/spec/OAuth.spec.js
@@ -242,22 +242,21 @@ describe('OAuth', function() {
  it("should only create a single user with REST API", (done) => {
    var objectId;
    createOAuthUser((error, response, body) => {
+      expect(error).toBe(null);
+      var b = JSON.parse(body);
+      expect(b.objectId).not.toBeNull();
+      expect(b.objectId).not.toBeUndefined();
+      objectId = b.objectId;
+
+      createOAuthUser((error, response, body) => {
        expect(error).toBe(null);
        var b = JSON.parse(body);
        expect(b.objectId).not.toBeNull();
        expect(b.objectId).not.toBeUndefined();
-        objectId = b.objectId;
-
-        createOAuthUser((error, response, body) => {
-          expect(error).toBe(null);
-          var b = JSON.parse(body);
-          expect(b.objectId).not.toBeNull();
-          expect(b.objectId).not.toBeUndefined();
-          expect(b.objectId).toBe(objectId);
-          done();
-        });
+        expect(b.objectId).toBe(objectId);
+        done();
      });
-
+    });
  });

  it("unlink and link with custom provider", (done) => {
--- a/spec/Schema.spec.js
+++ b/spec/Schema.spec.js
@@ -163,14 +163,26 @@ describe('Schema', () => {
    .then(schema => schema.addClassIfNotExists('NewClass', {
      foo: {type: 'String'}
    }))
-    .then(result => {
-      expect(result).toEqual({
-        _id: 'NewClass',
-        objectId: 'string',
-        updatedAt: 'string',
-        createdAt: 'string',
-        foo: 'string',
-      })
+    .then(actualSchema => {
+      const expectedSchema = {
+        className: 'NewClass',
+        fields: {
+          objectId: { type: 'String' },
+          updatedAt: { type: 'Date' },
+          createdAt: { type: 'Date' },
+          ACL: { type: 'ACL' },
+          foo: { type: 'String' },
+        },
+        classLevelPermissions: {
+          find: { '*': true },
+          get: { '*': true },
+          create: { '*': true },
+          update: { '*': true },
+          delete: { '*': true },
+          addField: { '*': true },
+        },
+      }
+      expect(dd(actualSchema, expectedSchema)).toEqual(undefined);
      done();
    })
    .catch(error => {
@@ -201,15 +213,27 @@ describe('Schema', () => {
    .then(schema => {
      var p1 = schema.addClassIfNotExists('NewClass', {foo: {type: 'String'}});
      var p2 = schema.addClassIfNotExists('NewClass', {foo: {type: 'String'}});
-      Promise.race([p1, p2]) //Use race because we expect the first completed promise to be the successful one
-      .then(response => {
-        expect(response).toEqual({
-          _id: 'NewClass',
-          objectId: 'string',
-          updatedAt: 'string',
-          createdAt: 'string',
-          foo: 'string',
-        });
+      Promise.race([p1, p2])
+      .then(actualSchema => {
+        const expectedSchema = {
+          className: 'NewClass',
+          fields: {
+            objectId: { type: 'String' },
+            updatedAt: { type: 'Date' },
+            createdAt: { type: 'Date' },
+            ACL: { type: 'ACL' },
+            foo: { type: 'String' },
+          },
+          classLevelPermissions: {
+            find: { '*': true },
+            get: { '*': true },
+            create: { '*': true },
+            update: { '*': true },
+            delete: { '*': true },
+            addField: { '*': true },
+          },
+        }
+        expect(dd(actualSchema, expectedSchema)).toEqual(undefined);
      });
      Promise.all([p1,p2])
      .catch(error => {
@@ -373,23 +397,36 @@ describe('Schema', () => {
      aPointer: {type: 'Pointer', targetClass: 'ThisClassDoesNotExistYet'},
      aRelation: {type: 'Relation', targetClass: 'NewClass'},
    }))
-    .then(mongoObj => {
-      expect(mongoObj).toEqual({
-        _id: 'NewClass',
-        objectId: 'string',
-        createdAt: 'string',
-        updatedAt: 'string',
-        aNumber: 'number',
-        aString: 'string',
-        aBool: 'boolean',
-        aDate: 'date',
-        aObject: 'object',
-        aArray: 'array',
-        aGeoPoint: 'geopoint',
-        aFile: 'file',
-        aPointer: '*ThisClassDoesNotExistYet',
-        aRelation: 'relation<NewClass>',
-      });
+    .then(actualSchema => {
+      const expectedSchema = {
+        className: 'NewClass',
+        fields: {
+          objectId: { type: 'String' },
+          updatedAt: { type: 'Date' },
+          createdAt: { type: 'Date' },
+          ACL: { type: 'ACL' },
+          aString: { type: 'String' },
+          aNumber: { type: 'Number' },
+          aString: { type: 'String' },
+          aBool: { type: 'Boolean' },
+          aDate: { type: 'Date' },
+          aObject: { type: 'Object' },
+          aArray: { type: 'Array' },
+          aGeoPoint: { type: 'GeoPoint' },
+          aFile: { type: 'File' },
+          aPointer: { type: 'Pointer', targetClass: 'ThisClassDoesNotExistYet' },
+          aRelation: { type: 'Relation', targetClass: 'NewClass' },
+        },
+        classLevelPermissions: {
+          find: { '*': true },
+          get: { '*': true },
+          create: { '*': true },
+          update: { '*': true },
+          delete: { '*': true },
+          addField: { '*': true },
+        },
+      }
+      expect(dd(actualSchema, expectedSchema)).toEqual(undefined);
      done();
    });
  });
@@ -399,23 +436,35 @@ describe('Schema', () => {
    .then(schema => schema.addClassIfNotExists('_Installation', {
      foo: {type: 'Number'},
    }))
-    .then(mongoObj => {
-      expect(mongoObj).toEqual({
-        _id: '_Installation',
-        createdAt: 'string',
-        updatedAt: 'string',
-        objectId: 'string',
-        foo: 'number',
-        installationId: 'string',
-        deviceToken: 'string',
-        channels: 'array',
-        deviceType: 'string',
-        pushType: 'string',
-        GCMSenderId: 'string',
-        timeZone: 'string',
-        localeIdentifier: 'string',
-        badge: 'number',
-      });
+    .then(actualSchema => {
+      const expectedSchema = {
+        className: '_Installation',
+        fields: {
+          objectId: { type: 'String' },
+          updatedAt: { type: 'Date' },
+          createdAt: { type: 'Date' },
+          ACL: { type: 'ACL' },
+          foo: { type: 'Number' },
+          installationId: { type: 'String' },
+          deviceToken: { type: 'String' },
+          channels: { type: 'Array' },
+          deviceType: { type: 'String' },
+          pushType: { type: 'String' },
+          GCMSenderId: { type: 'String' },
+          timeZone: { type: 'String' },
+          localeIdentifier: { type: 'String' },
+          badge: { type: 'Number' },
+        },
+        classLevelPermissions: {
+          find: { '*': true },
+          get: { '*': true },
+          create: { '*': true },
+          update: { '*': true },
+          delete: { '*': true },
+          addField: { '*': true },
+        },
+      }
+      expect(dd(actualSchema, expectedSchema)).toEqual(undefined);
      done();
    });
  });
@@ -423,16 +472,28 @@ describe('Schema', () => {
  it('creates non-custom classes which include relation field', done => {
    config.database.loadSchema()
    .then(schema => schema.addClassIfNotExists('_Role', {}))
-    .then(mongoObj => {
-      expect(mongoObj).toEqual({
-        _id: '_Role',
-        createdAt: 'string',
-        updatedAt: 'string',
-        objectId: 'string',
-        name: 'string',
-        users: 'relation<_User>',
-        roles: 'relation<_Role>',
-      });
+    .then(actualSchema => {
+      const expectedSchema = {
+        className: '_Role',
+        fields: {
+          objectId: { type: 'String' },
+          updatedAt: { type: 'Date' },
+          createdAt: { type: 'Date' },
+          ACL: { type: 'ACL' },
+          name: { type: 'String' },
+          users: { type: 'Relation', targetClass: '_User' },
+          roles: { type: 'Relation', targetClass: '_Role' },
+        },
+        classLevelPermissions: {
+          find: { '*': true },
+          get: { '*': true },
+          create: { '*': true },
+          update: { '*': true },
+          delete: { '*': true },
+          addField: { '*': true },
+        },
+      };
+      expect(dd(actualSchema, expectedSchema)).toEqual(undefined);
      done();
    });
  });
@@ -440,19 +501,31 @@ describe('Schema', () => {
  it('creates non-custom classes which include pointer field', done => {
    config.database.loadSchema()
    .then(schema => schema.addClassIfNotExists('_Session', {}))
-    .then(mongoObj => {
-      expect(mongoObj).toEqual({
-        _id: '_Session',
-        createdAt: 'string',
-        updatedAt: 'string',
-        objectId: 'string',
-        restricted: 'boolean',
-        user: '*_User',
-        installationId: 'string',
-        sessionToken: 'string',
-        expiresAt: 'date',
-        createdWith: 'object'
-      });
+    .then(actualSchema => {
+      const expectedSchema = {
+        className: '_Session',
+        fields: {
+          objectId: { type: 'String' },
+          updatedAt: { type: 'Date' },
+          createdAt: { type: 'Date' },
+          restricted: { type: 'Boolean' },
+          user: { type: 'Pointer', targetClass: '_User' },
+          installationId: { type: 'String' },
+          sessionToken: { type: 'String' },
+          expiresAt: { type: 'Date' },
+          createdWith: { type: 'Object' },
+          ACL: { type: 'ACL' },
+        },
+        classLevelPermissions: {
+          find: { '*': true },
+          get: { '*': true },
+          create: { '*': true },
+          update: { '*': true },
+          delete: { '*': true },
+          addField: { '*': true },
+        },
+      };
+      expect(dd(actualSchema, expectedSchema)).toEqual(undefined);
      done();
    });
  });
@@ -583,14 +656,26 @@ describe('Schema', () => {
      schema.addClassIfNotExists('NewClass', {
        relationField: {type: 'Relation', targetClass: '_User'}
      })
-      .then(mongoObj => {
-        expect(mongoObj).toEqual({
-          _id: 'NewClass',
-          objectId: 'string',
-          updatedAt: 'string',
-          createdAt: 'string',
-          relationField: 'relation<_User>',
-        });
+      .then(actualSchema => {
+        const expectedSchema = {
+          className: 'NewClass',
+          fields: {
+            objectId: { type: 'String' },
+            updatedAt: { type: 'Date' },
+            createdAt: { type: 'Date' },
+            ACL: { type: 'ACL' },
+            relationField: { type: 'Relation', targetClass: '_User' },
+          },
+          classLevelPermissions: {
+            find: { '*': true },
+            get: { '*': true },
+            create: { '*': true },
+            update: { '*': true },
+            delete: { '*': true },
+            addField: { '*': true },
+          },
+        };
+        expect(dd(actualSchema, expectedSchema)).toEqual(undefined);
      })
      .then(() => config.database.collectionExists('_Join:relationField:NewClass'))
      .then(exist => {
@@ -703,33 +788,4 @@ describe('Schema', () => {
    });
    done();
  });
-
-  it('handles legacy _client_permissions keys without crashing', done => {
-    Schema.mongoSchemaToSchemaAPIResponse({
-      "_id":"_Installation",
-      "_client_permissions":{
-        "get":true,
-        "find":true,
-        "update":true,
-        "create":true,
-        "delete":true,
-      },
-      "_metadata":{
-        "class_permissions":{
-          "get":{"*":true},
-          "find":{"*":true},
-          "update":{"*":true},
-          "create":{"*":true},
-          "delete":{"*":true},
-          "addField":{"*":true},
-        }
-      },
-      "installationId":"string",
-      "deviceToken":"string",
-      "deviceType":"string",
-      "channels":"array",
-      "user":"*_User",
-    });
-    done();
-  });
 });