Merge pull request parse-community#549 from flovilmart/refactors-adapter-controller

Improves Controller and Adapter relationship

Author: nlutsenko

spec/AdaptableController.spec.js

@@ -0,0 +1,87 @@
+
+var AdaptableController = require("../src/Controllers/AdaptableController").AdaptableController;
+var FilesAdapter = require("../src/Adapters/Files/FilesAdapter").default;
+var FilesController = require("../src/Controllers/FilesController").FilesController;
+
+var MockController = function(options) {
+  AdaptableController.call(this, options);
+}
+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);
+    expect(controller.adapter).toBe(adapter);
+    // make sure _adapter is private
+    expect(controller._adapter).toBe(undefined);
+    // Override _adapter is not doing anything
+    controller._adapter = "Hello";
+    expect(controller.adapter).toBe(adapter);
+    done();
+  });
+  
+  it("should throw when creating a new mock controller", (done) => {
+    var adapter = new FilesAdapter();
+    expect(() => {
+      new MockController(adapter);
+    }).toThrow();
+    done();
+  });
+  
+  it("should fail setting the wrong adapter to the controller", (done) => {
+    function WrongAdapter() {};
+    var adapter = new FilesAdapter();
+    var controller = new FilesController(adapter);
+    var otherAdapter = new WrongAdapter();
+    expect(() => {
+      controller.adapter = otherAdapter;
+    }).toThrow();
+    done();
+  });
+  
+  it("should fail to instantiate a controller with wrong adapter", (done) => {
+    function WrongAdapter() {};
+    var adapter = new WrongAdapter();
+    expect(() => {
+      new FilesController(adapter);
+    }).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) { },
+      deleteFile: function(config, filename) { },
+      getFileData: function(config, filename) { },
+      getFileLocation: function(config, filename) { },
+    }
+    expect(() => {
+      new FilesController(adapter);
+    }).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();
+  });
+});

spec/AdapterLoader.spec.js

@@ -0,0 +1,68 @@
+
+var AdapterLoader = require("../src/Adapters/AdapterLoader").AdapterLoader;
+var FilesAdapter = require("../src/Adapters/Files/FilesAdapter").default;
+
+describe("AdaptableController", ()=>{
+    
+  it("should instantiate an adapter from string in object", (done) => {
+    var adapterPath = require('path').resolve("./spec/MockAdapter");
+
+    var adapter = AdapterLoader.load({
+      adapter: adapterPath,
+      key: "value", 
+      foo: "bar"
+    });
+    
+    expect(adapter instanceof Object).toBe(true);
+    expect(adapter.options.key).toBe("value");
+    expect(adapter.options.foo).toBe("bar");
+    done();
+  });
+  
+  it("should instantiate an adapter from string", (done) => {
+    var adapterPath = require('path').resolve("./spec/MockAdapter");
+    var adapter = AdapterLoader.load(adapterPath);
+    
+    expect(adapter instanceof Object).toBe(true);
+    expect(adapter.options).toBe(adapterPath);
+    done();
+  });
+  
+  it("should instantiate an adapter from string that is module", (done) => {
+    var adapterPath = require('path').resolve("./src/Adapters/Files/FilesAdapter");
+    var adapter = AdapterLoader.load({
+      adapter: adapterPath
+    });
+    
+    expect(adapter instanceof FilesAdapter).toBe(true);
+    done();
+  });
+  
+  it("should instantiate an adapter from function/Class", (done) => {
+    var adapter = AdapterLoader.load({
+      adapter: FilesAdapter
+    });
+    expect(adapter instanceof FilesAdapter).toBe(true);
+    done();
+  });
+  
+  it("should instantiate the default adapter from Class", (done) => {
+    var adapter = AdapterLoader.load(null, FilesAdapter);
+    expect(adapter instanceof FilesAdapter).toBe(true);
+    done();
+  });
+  
+  it("should use the default adapter", (done) => {
+    var defaultAdapter = new FilesAdapter();
+    var adapter = AdapterLoader.load(null, defaultAdapter);
+    expect(adapter instanceof FilesAdapter).toBe(true);
+    done();
+  });
+  
+  it("should use the provided adapter", (done) => {
+    var originalAdapter = new FilesAdapter();
+    var adapter = AdapterLoader.load(originalAdapter);
+    expect(adapter).toBe(originalAdapter);
+    done();
+  });
+});

spec/FilesController.spec.js

@@ -1,12 +1,14 @@
 var FilesController = require('../src/Controllers/FilesController').FilesController;
+var GridStoreAdapter = require("../src/Adapters/Files/GridStoreAdapter").GridStoreAdapter;
 var Config = require("../src/Config");
 
 // Small additional tests to improve overall coverage
 describe("FilesController",()=>{
 
   it("should properly expand objects", (done) => {
     var config = new Config(Parse.applicationId);
-    var filesController = new FilesController();
+    var adapter = new GridStoreAdapter();
+    var filesController = new FilesController(adapter);
     var result = filesController.expandFilesInObject(config, function(){});
 
     expect(result).toBeUndefined();

spec/LoggerController.spec.js

@@ -76,11 +76,10 @@ describe('LoggerController', () => {
   });
 
   it('should throw without an adapter', (done) => {
-
-    var loggerController = new LoggerController();
+    
 
     expect(() => {
-      loggerController.getLogs();
+      var loggerController = new LoggerController();
     }).toThrow();
     done();
   });

spec/MockAdapter.js

@@ -0,0 +1,3 @@
+module.exports = function(options) {
+  this.options = options;
+}

spec/OneSignalPushAdapter.spec.js

@@ -227,7 +227,8 @@ describe('OneSignalPushAdapter', () => {
 
   function makeDevice(deviceToken, appIdentifier) {
     return {
-      deviceToken: deviceToken
+      deviceToken: deviceToken,
+      appIdentifier: appIdentifier
     };
   }
 

src/Adapters/AdapterLoader.js

@@ -0,0 +1,39 @@
+
+export class AdapterLoader {
+  static load(options, defaultAdapter) {
+    let adapter;
+
+    // We have options and options have adapter key
+    if (options) {
+      // Pass an adapter as a module name, a function or an instance
+      if (typeof options == "string" || typeof options == "function" || options.constructor != Object) {
+        adapter = options;
+      }
+      if (options.adapter) {
+        adapter = options.adapter;
+      }
+    }
+    
+    if (!adapter) {
+      adapter = defaultAdapter;
+    }
+
+    // This is a string, require the module
+    if (typeof adapter === "string") {
+      adapter = require(adapter);
+      // If it's define as a module, get the default
+      if (adapter.default) {
+        adapter = adapter.default;
+      }
+    }
+    // From there it's either a function or an object
+    // if it's an function, instanciate and pass the options 
+    if (typeof adapter === "function") {
+      var Adapter = adapter;
+      adapter = new Adapter(options);
+    }
+    return adapter;
+  }
+}
+
+export default AdapterLoader;