pageflow-react 0.1.0

data/js/spec/resolve_spec.js

@@ -0,0 +1,3 @@
+describe('resolve', () => {
+  
+});

data/js/spec/resolvers/backbone_model_resolver_spec.js

@@ -0,0 +1,256 @@
+import BackboneModelResolver from 'resolvers/backbone_model_resolver';
+
+import Backbone from 'backbone';
+
+import sinon from 'sinon';
+
+describe('BackboneModelResolver', () => {
+  it('gets props from model attributes referenced by id', () => {
+    var collection = new Backbone.Collection([{id: 1, title: 'Some title'}]);
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', 'title'],
+      property: 'modelId'
+    });
+
+    var result = modelResolver.get({modelId: 1});
+
+    expect(result).to.deep.eq({id: 1, title: 'Some title'})
+  });
+
+  it('can map attribute names', () => {
+    var collection = new Backbone.Collection([{id: 1, template: 'background_image'}]);
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', ['type', 'template']],
+      property: 'modelId'
+    });
+
+    var result = modelResolver.get({modelId: 1});
+
+    expect(result).to.deep.eq({id: 1, type: 'background_image'})
+  });
+
+  it('camelizes attribute names', () => {
+    var collection = new Backbone.Collection([{id: 1, image_id: 2}]);
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', 'image_id'],
+      property: 'modelId'
+    });
+
+    var result = modelResolver.get({modelId: 1});
+
+    expect(result).to.deep.eq({id: 1, imageId: 2})
+  });
+
+  it('resolves to null if property is missing', () => {
+    var collection = new Backbone.Collection();
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      property: 'modelId'
+    });
+
+    var result = modelResolver.get({});
+
+    expect(result).to.deep.eq(null)
+  });
+
+  it('resolves to null if model cannot be found', () => {
+    var collection = new Backbone.Collection();
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      property: 'modelId'
+    });
+
+    var result = modelResolver.get({modelId: 1000});
+
+    expect(result).to.deep.eq(null)
+  });
+
+  it('can use custom id attribute', () => {
+    var collection = new Backbone.Collection([{id: 1, permaId: 100, title: 'Some title'}]);
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      idAttribute: 'permaId',
+      attributesForProps: ['id', 'title'],
+      property: 'modelPermaId'
+    });
+
+    var result = modelResolver.get({modelPermaId: 100});
+
+    expect(result).to.deep.eq({id: 1, title: 'Some title'})
+  });
+
+  it('gets props from new model after property value changes', () => {
+    var collection = new Backbone.Collection([
+      {id: 1, title: 'Some title'},
+      {id: 2, title: 'Some other title'}
+    ]);
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', 'title'],
+      property: 'modelId'
+    });
+
+    modelResolver.get({modelId: 1});
+    var result = modelResolver.get({modelId: 2});
+
+    expect(result).to.deep.eq({id: 2, title: 'Some other title'})
+  });
+
+  it('invokes callback when prop attribute changes', () => {
+    var collection = new Backbone.Collection([{id: 1, title: 'Some title'}]);
+    var callback = sinon.spy();
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', 'title'],
+      property: 'modelId'
+    }, callback);
+
+    modelResolver.get({modelId: 1});
+    collection.first().set('title', 'Changed title');
+
+    expect(callback).to.have.been.called;
+  });
+
+  it('does not invoke callback when other attributes changes', () => {
+    var collection = new Backbone.Collection([{id: 1, title: 'Some title'}]);
+    var callback = sinon.spy();
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', 'title'],
+      property: 'modelId'
+    }, callback);
+
+    modelResolver.get({modelId: 1});
+    collection.first().set('text', 'Changed text');
+
+    expect(callback).not.to.have.been.called;
+  });
+
+  it('starts listening to new model on prop change', () => {
+    var collection = new Backbone.Collection([
+      {id: 1, title: 'Some title'},
+      {id: 2, title: 'Some other title'}
+    ]);
+    var callback = sinon.spy();
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', 'title'],
+      property: 'modelId'
+    }, callback);
+
+    modelResolver.get({modelId: 1});
+    modelResolver.get({modelId: 2});
+    collection.get(2).set('title', 'Changed text');
+
+    expect(callback).to.have.been.called;
+  });
+
+  it('stops listening to model on prop change', () => {
+    var collection = new Backbone.Collection([
+      {id: 1, title: 'Some title'},
+      {id: 2, title: 'Some other title'}
+    ]);
+    var callback = sinon.spy();
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', 'title'],
+      property: 'modelId'
+    }, callback);
+
+    modelResolver.get({modelId: 1});
+    modelResolver.get({modelId: 2});
+    collection.get(1).set('title', 'Changed text');
+
+    expect(callback).not.to.have.been.called;
+  });
+
+  it('stops listening to model on dispose', () => {
+    var collection = new Backbone.Collection([{id: 1, title: 'Some title'}]);
+    var callback = sinon.spy();
+    var modelResolver = new BackboneModelResolver({
+      collection: () => collection,
+      attributesForProps: ['id', 'title'],
+      property: 'modelId'
+    }, callback);
+
+    modelResolver.get({modelId: 1});
+    modelResolver.dispose();
+    collection.first().set('title', 'Changed title');
+
+    expect(callback).not.to.have.been.called;
+  });
+
+  context('with includeConfiguration option', () => {
+    it('includes attributes from a nested configuration model', () => {
+      var collection = new Backbone.Collection([{id: 1}]);
+      collection.first().configuration = new Backbone.Model({text: 'Some text'});
+      var modelResolver = new BackboneModelResolver({
+        collection: () => collection,
+        includeConfiguration: true,
+        property: 'modelId'
+      });
+
+      var result = modelResolver.get({modelId: 1});
+
+      expect(result).to.deep.eq({id: 1, text: 'Some text'})
+    });
+
+    it('invokes callback when configuration changes', () => {
+      var collection = new Backbone.Collection([{id: 1}]);
+      collection.first().configuration = new Backbone.Model({text: 'Some text'});
+      var callback = sinon.spy();
+      var modelResolver = new BackboneModelResolver({
+        collection: () => collection,
+        includeConfiguration: true,
+        property: 'modelId'
+      }, callback);
+
+      modelResolver.get({modelId: 1});
+      collection.first().configuration.set('title', 'Changed title');
+
+      expect(callback).to.have.been.called;
+    });
+
+    it('stops listening to model configuration on prop change', () => {
+      var collection = new Backbone.Collection([{id: 1}, {id: 2}]);
+      collection.get(1).configuration = new Backbone.Model({title: 'Some text'});
+      collection.get(2).configuration = new Backbone.Model({title: 'Some other text'});
+      var callback = sinon.spy();
+      var modelResolver = new BackboneModelResolver({
+        collection: () => collection,
+        attributesForProps: ['id', 'title'],
+        includeConfiguration: true,
+        property: 'modelId'
+      }, callback);
+
+      modelResolver.get({modelId: 1});
+      modelResolver.get({modelId: 2});
+      collection.get(1).configuration.set('title', 'Changed text');
+
+      expect(callback).not.to.have.been.called;
+    });
+
+    it('deeply camelizes configuration attribute names', () => {
+      var collection = new Backbone.Collection([{id: 1}]);
+      collection.first().configuration = new Backbone.Model({
+        page_links: [
+          {
+            image_id: 1
+          }
+        ]
+      });
+      var modelResolver = new BackboneModelResolver({
+        collection: () => collection,
+        includeConfiguration: true,
+        property: 'modelId'
+      });
+
+      var result = modelResolver.get({modelId: 1});
+
+      expect(result).to.deep.eq({id: 1, pageLinks: [{imageId: 1}]})
+    });
+  });
+});

data/js/spec/resolvers/create_recursive_resolver_spec.js

@@ -0,0 +1,120 @@
+import Resolver from 'resolvers/resolver';
+import createRecursiveResolver from 'resolvers/create_recursive_resolver';
+
+import sinon from 'sinon';
+
+describe('resolver created by createRecursiveResolver', () => {
+  class FakeResolver extends Resolver {
+    constructor(options, callback) {
+      super(callback);
+
+      this.dispose = options.onDispose || sinon.spy();
+      this._triggerCallbackOnGet = options.triggerCallbackOnGet;
+      this._result = options.result;
+    }
+
+    get(props, seed) {
+      if (this._triggerCallbackOnGet) {
+        this.triggerCallback();
+      }
+
+      return this._result;
+    }
+
+    triggerCallback() {
+      this._handleChange();
+    }
+  }
+
+  it('returns result of decorated resolver', () => {
+    const RecursiveResolver = createRecursiveResolver(FakeResolver);
+    const resolver = new RecursiveResolver({
+      result: {chapterId: 5}
+    });
+
+    var result = resolver.get();
+
+    expect(result.chapterId).to.eq(5);
+  });
+
+  it('uses fragments to resolve properties in result', () => {
+    const RecursiveResolver = createRecursiveResolver(FakeResolver);
+    const resolver = new RecursiveResolver({
+      result: {chapterId: 5},
+      fragments: {
+        chapter: (callback) => new FakeResolver({result: 'chapter'}, callback)
+      }
+    });
+
+    var result = resolver.get();
+
+    expect(result.chapter).to.eq('chapter');
+  });
+
+  it('invokes callback when the nested resolver signals a change', () => {
+    const RecursiveResolver = createRecursiveResolver(FakeResolver);
+    const callback = sinon.spy();
+    var nestedResolver;
+    const resolver = new RecursiveResolver({
+      result: {chapterId: 5},
+      fragments: {
+        chapter: (callback) => {
+          nestedResolver = new FakeResolver({result: 'chapter'}, callback);
+          return nestedResolver;
+        }
+      }
+    }, callback);
+
+    resolver.get();
+    nestedResolver.triggerCallback();
+
+    expect(callback).to.have.been.called;
+  });
+
+  it('invokes callback when the decorated resolver signals a change', () => {
+    const RecursiveResolver = createRecursiveResolver(FakeResolver);
+    const callback = sinon.spy();
+    const resolver = new RecursiveResolver({
+      triggerCallbackOnGet: true,
+      result: {chapterId: 5},
+    }, callback);
+
+    resolver.get();
+
+    expect(callback).to.have.been.called;
+  });
+
+  it('passes dispose on nested resolver', () => {
+    const RecursiveResolver = createRecursiveResolver(FakeResolver);
+    var nestedResolver;
+    const resolver = new RecursiveResolver({
+      result: {chapterId: 5},
+      fragments: {
+        chapter: (callback) => {
+          nestedResolver = new FakeResolver({result: 'chapter'}, callback);
+          return nestedResolver;
+        }
+      }
+    }, () => {});
+
+    resolver.get();
+    resolver.dispose();
+
+    expect(nestedResolver.dispose).to.have.been.called;
+  });
+
+  it('passes dispose to decorated resolver', () => {
+    const RecursiveResolver = createRecursiveResolver(FakeResolver);
+    var disposed = false;
+    const resolver = new RecursiveResolver({
+      triggerCallbackOnGet: true,
+      onDispose: () => { disposed = true; },
+      result: {chapterId: 5},
+    }, () => {});
+
+    resolver.get();
+    resolver.dispose();
+
+    expect(disposed).to.eq(true);
+  });
+});

data/js/spec/resolvers/editor_file_ids_resolver_spec.js

@@ -0,0 +1,49 @@
+import EditorFileIdsResolver from 'resolvers/editor_file_ids_resolver';
+
+import Backbone from 'backbone';
+
+import sinon from 'sinon';
+
+describe('EditorFileIdsResolver', () => {
+  it('gets ids of files indexed by collection name', () => {
+    var files = {
+      image_files: new Backbone.Collection([{id: 1}, {id: 3}])
+    };
+    var resolver = new EditorFileIdsResolver({
+      collections: () => files
+    });
+
+    var result = resolver.get();
+
+    expect(result).to.deep.eq({image_files: [1, 3]})
+  });
+
+  it('invokes callback when prop attribute changes', () => {
+    var files = {
+      image_files: new Backbone.Collection([{id: 1}])
+    };
+    var callback = sinon.spy();
+    new EditorFileIdsResolver({
+      collections: () => files
+    }, callback);
+
+    files.image_files.shift();
+
+    expect(callback).to.have.been.called;
+  });
+
+  it('stops invokes callback after dispose', () => {
+    var files = {
+      image_files: new Backbone.Collection([{id: 1}])
+    };
+    var callback = sinon.spy();
+    var resolver = new EditorFileIdsResolver({
+      collections: () => files
+    }, callback);
+
+    resolver.dispose();
+    files.image_files.shift();
+
+    expect(callback).not.to.have.been.called;
+  });
+});

data/js/spec/resolvers/i18n_resolver_spec.js

@@ -0,0 +1,20 @@
+import I18nResolver from 'resolvers/i18n_resolver';
+
+import sinon from 'sinon';
+
+describe('I18nResolver', () => {
+  it('provides translate function for entry locale', () => {
+    window.I18n = {
+      t: sinon.spy()
+    };
+
+    var seed = {
+      locale: 'fr'
+    };
+    var resolver = new I18nResolver();
+
+    resolver.get({}, seed).t('some.key');
+
+    expect(I18n.t).to.have.been.calledWith('some.key', {locale: 'fr'});
+  });
+});