Fix tests

test/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "env": {
+    "mocha": true
+  }
+}

test/colorize.test.js

@@ -1,14 +1,13 @@
-
-var expect = require('expect.js')
-  , colorize = require('../lib/colorize')
+var expect = require('expect.js');
+var colorize = require('../lib/colorize');
 
 describe('colorize', function () {
-  var message = 'hello strider'
+  var message = 'hello strider';
   Object.keys(colorize).forEach(function (name) {
     describe(name, function () {
       it('should return a string that contains the original message', function () {
-        expect(colorize[name](message)).to.contain(message)
-      })
-    })
-  })
-})
+        expect(colorize[name](message)).to.contain(message);
+      });
+    });
+  });
+});

test/test_job.js

@@ -1,27 +1,32 @@
-var expect = require('expect.js')
-  , EventEmitter = require('events').EventEmitter
-  , Job = require('../').Job
+var expect = require('expect.js');
+var EventEmitter = require('events').EventEmitter;
+var Job = require('../').Job;
 
 describe('Job', function () {
-  var job
+  var job;
   describe('with no plugins', function () {
     beforeEach(function () {
       job = new Job(
-        { id: 'man'
+        {
+          id: 'man',
+          project: {
+            display_name: 'testing'
+          }
         },
-        { fetch: function (dest, userConfig, config, done) {
-          done(null)
-        }
-      }, [], {
-        io: new EventEmitter()
-      })
-    })
+        {
+          fetch: function (dest, userConfig, config, done) {
+            done(null);
+          }
+        }, [], {
+          io: new EventEmitter()
+        });
+    });
     it('should fail', function (done) {
-      this.timeout(30)
+      this.timeout(30);
       job.run(function (err) {
-        expect(err.message).to.match(/plugin/)
-        done()
-      })
-    })
-  })
-})
+        expect(err.message).to.match(/plugin/);
+        done();
+      });
+    });
+  });
+});

test/test_run.js

@@ -1,67 +1,72 @@
-var processBuildJob = require('../').process
-  , EventEmitter = require('events').EventEmitter
+var processBuildJob = require('../').process;
+var EventEmitter = require('events').EventEmitter;
 
 describe('Integration', function () {
   it('should just work', function (done) {
-    var called =
-      { fetch: false
-      , environment: false
-      , prepare: false
-      , test: false
-      , deploy: false
-      , cleanup: false
-      , listen: false
-      }
+    var called = {
+      fetch: false,
+      environment: false,
+      prepare: false,
+      test: false,
+      deploy: false,
+      cleanup: false,
+      listen: false
+    };
+
     function cachier() {
-      return cachier
+      return cachier;
     }
+
     processBuildJob({
       id: '123',
+      project: {
+        display_name: 'testing'
+      },
       type: 'TEST_AND_DEPLOY',
       ref: {
         branch: 'master'
       }
     }, { // provider
       fetch: function (context, done) {
-        called.fetch = true
-        done()
+        called.fetch = true;
+        done();
       }
     }, [{ // jobplugins
       listen: function () {
-        called.listen = true
+        called.listen = true;
       },
       environment: function (context, done) {
-        called.environment = true
-        done(null, true)
+        called.environment = true;
+        done(null, true);
       },
       prepare: function (context, done) {
-        called.prepare = true
-        done(null, true)
+        called.prepare = true;
+        done(null, true);
       },
       test: function (context, done) {
-        called.test = true
-        done(null, true)
+        called.test = true;
+        done(null, true);
       },
       deploy: function (context, done) {
-        called.deploy = true
-        done(null, true)
+        called.deploy = true;
+        done(null, true);
       },
       cleanup: function (context, done) {
-        called.cleanup = true
-        done(null, true)
+        called.cleanup = true;
+        done(null, true);
       }
     }], { // config
       dataDir: '/tmp/',
       cachier: cachier,
       io: new EventEmitter()
     }, function (err) {
-      if (err) return done(err)
+      if (err) return done(err);
       for (var name in called) {
         if (!called[name]) {
-          return done(new Error(name + ' was not called'))
+          return done(new Error(name + ' was not called'));
         }
       }
-      done()
-    })
-  })
-})
+      done();
+    });
+  });
+});

test/utils.test.js

@@ -1,61 +1,63 @@
 
-var expect = require('expect.js')
-  , utils = require('../lib/utils')
+var expect = require('expect.js');
+var utils = require('../lib/utils');
 
 describe('utils', function () {
   describe('exitError', function () {
     it('should return a subclass of error', function () {
-      expect(utils.exitError('ls', 27)).to.be.an(Error)
-    })
+      expect(utils.exitError('ls', 27)).to.be.an(Error);
+    });
     it('should have a "code" attribute indicating the exit code', function () {
-      expect(utils.exitError('ls', 27).code).to.equal(27)
-    })
-  })
+      expect(utils.exitError('ls', 27).code).to.equal(27);
+    });
+  });
 
   describe('sum', function () {
     it('should calculate correctly', function () {
-      expect(utils.sum([12,3,4])).to.equal(19)
-    })
-  })
+      expect(utils.sum([12,3,4])).to.equal(19);
+    });
+  });
 
   describe('runPlugin', function () {
     describe('with no action for that phase', function () {
-      var plugin = {}
+      var plugin = {};
       it('should noop', function (done) {
-        utils.runPlugin('test', plugin, {}, done)
-      })
-    })
+        utils.runPlugin('test', plugin, {}, done);
+      });
+    });
     describe('with a string action', function () {
       it('should call context.cmd', function (done) {
         utils.runPlugin('test', {'test': 'ls'}, {
           cmd: function (text) {
-            expect(text).to.equal('ls')
-            done()
+            expect(text).to.equal('ls');
+            done();
           }
-        }, null)
-      })
-    })
+        }, null);
+      });
+    });
     describe('with an executable action', function () {
       it('should call the action', function (done) {
         utils.runPlugin('test', {
-          test: function () {done()}
-        }, {}, null)
-      })
-    })
-  })
+          test: function () {
+            done();
+          }
+        }, {}, null);
+      });
+    });
+  });
 
   describe('normalizeCmd', function () {
     it('should process a string', function () {
-      var cmd = utils.normalizeCmd('ls -l -a')
-      expect(cmd.command).to.equal('ls')
-      expect(cmd.args).to.eql(['-l', '-a'])
-    })
+      var cmd = utils.normalizeCmd('ls -l -a');
+      expect(cmd.command).to.equal('ls');
+      expect(cmd.args).to.eql(['-l', '-a']);
+    });
 
     it('should process a command and args', function () {
-      var cmd = utils.normalizeCmd({command: 'ls', args: ['-a']})
-      expect(cmd.command).to.equal('ls')
-      expect(cmd.args).to.eql(['-a'])
-    })
-  })
-})
+      var cmd = utils.normalizeCmd({command: 'ls', args: ['-a']});
+      expect(cmd.command).to.equal('ls');
+      expect(cmd.args).to.eql(['-a']);
+    });
+  });
+});