Added activate hook to activate a revisionKey

achambers · achambers · commit 44813a66119a · 2015-06-23T12:58:31.000+01:00
diff --git a/index.js b/index.js
@@ -93,9 +93,22 @@ module.exports = {
           .catch(_errorMessage.bind(this, ui));
       },
 
+      activate: function(context) {
+        var deployment  = context.deployment;
+        var ui          = deployment.ui;
+        var config      = deployment.config[this.name] || {};
+        var redis       = context.redisClient || new Redis(config);
+        var revisionKey = this._resolveConfigValue('revisionKey', config, context);
+
+        return _beginActivateMessage(ui, revisionKey)
+          .then(redis.activate.bind(redis, config.keyPrefix, revisionKey))
+          .then(_activationSuccessMessage.bind(this, ui, revisionKey))
+          .catch(_errorMessage.bind(this, ui));
+      },
+
       _resolvePipelineData: function(config, context) {
         config.revisionKey = config.revisionKey || function(context) {
-          return context.deployment.commandLineArgs.revisionKey || context.deployment.revisionKey;
+          return context.deployment.commandLineArgs.revisionKey || context.revisionKey;
         };
 
         return Promise.resolve();
diff --git a/tests/unit/index-nodetest.js b/tests/unit/index-nodetest.js
@@ -4,6 +4,19 @@ var Promise = require('ember-cli/lib/ext/promise');
 
 var assert  = require('ember-cli/tests/helpers/assert');
 
+function hooks(plugin) {
+  return Object.keys(plugin).filter(function(key) {
+    return (key !== 'name') && (key.charAt(0) !== '_') && (typeof plugin[key] === 'function');
+  });
+}
+
+var stubUi      = { write: function() {}, writeLine: function() {} };
+var stubProject = {
+  name: function(){
+    return 'my-project';
+  }
+};
+
 describe('redis plugin', function() {
   var subject;
 
@@ -20,28 +33,24 @@ describe('redis plugin', function() {
   });
 
   it('implements the correct hooks', function() {
-    var result = subject.createDeployPlugin({
+    var plugin = subject.createDeployPlugin({
       name: 'test-plugin'
     });
 
-    assert.equal(typeof result.configure, 'function');
-    assert.equal(typeof result.upload, 'function');
+    assert.equal(hooks(plugin).length, 3);
+    assert.sameMembers(hooks(plugin), ['configure', 'upload', 'activate']);
   });
 
-  describe('willDeploy hook', function() {
+  describe('configure hook', function() {
     it('resolves if config is ok', function() {
       var plugin = subject.createDeployPlugin({
         name: 'redis'
       });
 
       var context = {
         deployment: {
-          ui: { write: function() {}, writeLine: function() {} },
-          project: {
-            name: function(){
-              return 'my-project';
-            }
-          },
+          ui: stubUi,
+          project: stubProject,
           config: {
             redis: {
               host: 'somehost',
@@ -53,6 +62,96 @@ describe('redis plugin', function() {
 
       return assert.isFulfilled(plugin.configure.call(plugin, context))
     });
+
+    describe('resolving data from the pipeline', function() {
+      it('uses the config data if it already exists', function() {
+        var plugin = subject.createDeployPlugin({
+          name: 'redis'
+        });
+
+        var config = {
+          host: 'somehost',
+          port: 1234,
+          revisionKey: '12345'
+        };
+        var context = {
+          deployment: {
+            ui: stubUi,
+            project: stubProject,
+            config: {
+              redis: config
+            }
+          },
+
+          revisionKey: 'something-else'
+        };
+
+        return assert.isFulfilled(plugin.configure.call(plugin, context))
+          .then(function() {
+            assert.equal(config.revisionKey, '12345');
+          });
+      });
+
+      it('uses the commandLineArgs value if it exists', function() {
+        var plugin = subject.createDeployPlugin({
+          name: 'redis'
+        });
+
+        var config = {
+          host: 'somehost',
+          port: 1234
+        };
+        var context = {
+          deployment: {
+            ui: stubUi,
+            project: stubProject,
+            config: {
+              redis: config
+            },
+            commandLineArgs: {
+              revisionKey: 'abcd'
+            }
+          },
+
+          revisionKey: 'something-else'
+        };
+
+        return assert.isFulfilled(plugin.configure.call(plugin, context))
+          .then(function() {
+            assert.typeOf(config.revisionKey, 'function');
+            assert.equal(config.revisionKey(context), 'abcd');
+          });
+      })
+
+      it('uses the context value if it exists and commandLineArgs don\'t', function() {
+        var plugin = subject.createDeployPlugin({
+          name: 'redis'
+        });
+
+        var config = {
+          host: 'somehost',
+          port: 1234
+        };
+        var context = {
+          deployment: {
+            ui: stubUi,
+            project: stubProject,
+            config: {
+              redis: config
+            },
+            commandLineArgs: { }
+          },
+
+          revisionKey: 'something-else'
+        };
+
+        return assert.isFulfilled(plugin.configure.call(plugin, context))
+          .then(function() {
+            assert.typeOf(config.revisionKey, 'function');
+            assert.equal(config.revisionKey(context), 'something-else');
+          });
+      })
+    });
   });
 
   describe('upload hook', function() {
@@ -66,34 +165,95 @@ describe('redis plugin', function() {
 
       context = {
         redisClient: {
-          upload: function() {
-            return Promise.resolve('redis-key');
+          upload: function(keyPrefix, revisionKey) {
+            return Promise.resolve(keyPrefix + ':' + revisionKey);
           }
         },
         tag: 'some-tag',
         deployment: {
-          ui: { write: function() {} },
-          project: { name: function() { return 'test-project'; } },
+          ui: stubUi,
+          project: stubProject,
           config: {
             redis: {
+              keyPrefix: 'test-prefix',
               filePattern: 'tests/index.html',
+              revisionKey: '123abc'
             }
           }
-        }
+        },
       };
     });
 
-    it('uploads the index to redis', function() {
+    it('uploads the index', function() {
       return assert.isFulfilled(plugin.upload.call(plugin, context))
         .then(function(result) {
-          assert.deepEqual(result, { redisKey: 'redis-key' });
+          assert.deepEqual(result, { redisKey: 'test-prefix:123abc' });
         });
     });
+  });
 
-    it('returns the uploaded key', function() {
-      return assert.isFulfilled(plugin.upload.call(plugin, context))
-        .then(function(result) {
-          assert.deepEqual(result.redisKey, 'redis-key');
+  describe('activate hook', function() {
+    it('activates revision', function() {
+      var activateCalled = false;
+
+      var plugin = subject.createDeployPlugin({
+        name: 'redis'
+      });
+
+      var context = {
+        redisClient: {
+          activate: function() {
+            activateCalled = true;
+          }
+        },
+        tag: 'some-tag',
+        deployment: {
+          ui: stubUi,
+          project: stubProject,
+          config: {
+            redis: {
+              keyPrefix: 'test-prefix',
+              filePattern: 'tests/index.html',
+              revisionKey: '123abc'
+            }
+          }
+        }
+      };
+
+      return assert.isFulfilled(plugin.activate.call(plugin, context))
+        .then(function() {
+          assert.ok(activateCalled);
+        });
+    });
+
+    it('rejects if an error is thrown when activating', function() {
+      var plugin = subject.createDeployPlugin({
+        name: 'redis'
+      });
+
+      var context = {
+        redisClient: {
+          activate: function() {
+            return Promise.reject('some-error');
+          }
+        },
+        tag: 'some-tag',
+        deployment: {
+          ui: stubUi,
+          project: stubProject,
+          config: {
+            redis: {
+              keyPrefix: 'test-prefix',
+              filePattern: 'tests/index.html',
+              revisionKey: '123abc'
+            }
+          }
+        }
+      };
+
+      return assert.isRejected(plugin.activate.call(plugin, context))
+        .then(function(error) {
+          assert.equal(error, 'some-error');
         });
     });
   });
diff --git a/tests/unit/lib/redis-nodetest.js b/tests/unit/lib/redis-nodetest.js
@@ -169,4 +169,48 @@ describe('redis', function() {
       });
     });
   });
+
+  describe('#activate', function() {
+    it('rejects if the revisionKey doesn\t exist in list of uploaded revisions', function() {
+      var recentRevisions = ['a', 'b', 'c'];
+
+      var redis = new Redis({
+        redisClient: {
+          lrange: function() {
+            return recentRevisions;
+          }
+        }
+      });
+
+      var promise = redis.activate('key-prefix', 'revision-key');
+      return assert.isRejected(promise)
+        .then(function(error) {
+          assert.equal(error, '`revision-key` is not a valid revision key');
+        });
+    });
+
+    it('resolves and sets the current revision to the revision key provided', function() {
+      var recentRevisions = ['a', 'b', 'c'];
+      var redisKey, redisValue;
+
+      var redis = new Redis({
+        redisClient: {
+          lrange: function() {
+            return recentRevisions;
+          },
+          set: function(key, value) {
+            redisKey = key;
+            redisValue = value;
+          }
+        }
+      });
+
+      var promise = redis.activate('key-prefix', 'c');
+      return assert.isFulfilled(promise)
+        .then(function() {
+          assert.equal(redisKey, 'key-prefix:current');
+          assert.equal(redisValue, 'c');
+        });
+    });
+  });
 });
