Merge branch 'm7r_helper' of https://github.com/m7r/jasmine-npm into m7r-m7r_helper

Author: Gregg Van Hove

lib/command.js

@@ -57,6 +57,7 @@ function isFileArg(arg) {
 
 function parseOptions(argv) {
   var files = [],
+      helpers = [],
       color = process.stdout.isTTY || false,
       filter,
       stopOnFailure,
@@ -68,6 +69,8 @@ function parseOptions(argv) {
       color = false;
     } else if (arg.match("^--filter=")) {
       filter = arg.match("^--filter=(.*)")[1];
+    } else if (arg.match("^--helper=")) {
+      helpers.push(arg.match("^--helper=(.*)")[1]);
     } else if (arg.match("^--stop-on-failure=")) {
       stopOnFailure = arg.match("^--stop-on-failure=(.*)")[1] === 'true';
     } else if (arg.match("^--random=")) {
@@ -82,6 +85,7 @@ function parseOptions(argv) {
     color: color,
     filter: filter,
     stopOnFailure: stopOnFailure,
+    helpers: helpers,
     files: files,
     random: random,
     seed: seed
@@ -99,6 +103,9 @@ function runJasmine(jasmine, env) {
   if (env.random !== undefined) {
     jasmine.randomizeTests(env.random);
   }
+  if (env.helpers !== undefined && env.helpers.length) {
+    jasmine.addHelperFiles(env.helpers);
+  }
   jasmine.showColors(env.color);
   jasmine.execute(env.files, env.filter);
 }
@@ -164,6 +171,7 @@ function help(options) {
   print('Options:');
   print('%s\tturn off color in spec output', lPad('--no-color', 18));
   print('%s\tfilter specs to run only those that match the given string', lPad('--filter=', 18));
+  print('%s\tload helper files that match the given string', lPad('--helper=', 18));
   print('%s\t[true|false] stop spec execution on expectation failure', lPad('--stop-on-failure=', 18));
   print('');
   print('The given arguments take precedence over options in your jasmine.json');

lib/jasmine.js

@@ -15,6 +15,7 @@ function Jasmine(options) {
   this.jasmine = jasmineCore.boot(jasmineCore);
   this.projectBaseDir = options.projectBaseDir || path.resolve();
   this.printDeprecation = options.printDeprecation || require('./printDeprecation');
+  this.specDir = '';
   this.specFiles = [];
   this.helperFiles = [];
   this.env = this.jasmine.getEnv();
@@ -102,40 +103,40 @@ Jasmine.prototype.loadConfigFile = function(configFilePath) {
 };
 
 Jasmine.prototype.loadConfig = function(config) {
-  var jasmineRunner = this;
-  jasmineRunner.specDir = config.spec_dir || '';
+  this.specDir = config.spec_dir || this.specDir;
+  this.env.throwOnExpectationFailure(config.stopSpecOnExpectationFailure);
+  this.env.randomizeTests(config.random);
 
   if(config.helpers) {
-    config.helpers.forEach(function(helperFile) {
-      var filePaths = glob.sync(path.join(jasmineRunner.projectBaseDir, jasmineRunner.specDir, helperFile));
-      filePaths.forEach(function(filePath) {
-        if(jasmineRunner.helperFiles.indexOf(filePath) === -1) {
-          jasmineRunner.helperFiles.push(filePath);
-        }
-      });
-    });
+    this.addHelperFiles(config.helpers);
   }
 
-  this.env.throwOnExpectationFailure(config.stopSpecOnExpectationFailure);
-  this.env.randomizeTests(config.random);
-
   if(config.spec_files) {
-    jasmineRunner.addSpecFiles(config.spec_files);
+    this.addSpecFiles(config.spec_files);
   }
 };
 
-Jasmine.prototype.addSpecFiles = function(files) {
-  var jasmineRunner = this;
+Jasmine.prototype.addHelperFiles = addFiles('helperFiles');
+Jasmine.prototype.addSpecFiles = addFiles('specFiles');
+
+function addFiles(kind) {
+  return function (files) {
+    var jasmineRunner = this;
+    var fileArr = this[kind];
 
-  files.forEach(function(specFile) {
-    var filePaths = glob.sync(path.join(jasmineRunner.projectBaseDir, jasmineRunner.specDir, specFile));
-    filePaths.forEach(function(filePath) {
-      if(jasmineRunner.specFiles.indexOf(filePath) === -1) {
-        jasmineRunner.specFiles.push(filePath);
+    files.forEach(function(file) {
+      if(!(path.isAbsolute && path.isAbsolute(file))) {
+        file = path.join(jasmineRunner.projectBaseDir, jasmineRunner.specDir, file);
       }
+      var filePaths = glob.sync(file);
+      filePaths.forEach(function(filePath) {
+        if(fileArr.indexOf(filePath) === -1) {
+          fileArr.push(filePath);
+        }
+      });
     });
-  });
-};
+  };
+}
 
 Jasmine.prototype.onComplete = function(onCompleteCallback) {
   this.completionReporter.onComplete(onCompleteCallback);

spec/command_spec.js

@@ -42,7 +42,7 @@ describe('command', function() {
 
     this.command = new Command(projectBaseDir, examplesDir, this.out.print);
 
-    this.fakeJasmine = jasmine.createSpyObj('jasmine', ['loadConfigFile', 'showColors', 'execute', 'stopSpecOnExpectationFailure', 'randomizeTests', 'seed', 'coreVersion']);
+    this.fakeJasmine = jasmine.createSpyObj('jasmine', ['loadConfigFile', 'addHelperFiles', 'showColors', 'execute', 'stopSpecOnExpectationFailure', 'randomizeTests', 'seed', 'coreVersion']);
   });
 
   afterEach(function() {
@@ -197,6 +197,21 @@ describe('command', function() {
       expect(this.fakeJasmine.execute).toHaveBeenCalledWith(jasmine.any(Array), 'interesting spec');
     });
 
+    it('should be able to add one helper pattern', function() {
+      this.command.run(this.fakeJasmine, ['--helper=helpers/**/*.js']);
+      expect(this.fakeJasmine.addHelperFiles).toHaveBeenCalledWith(['helpers/**/*.js']);
+    });
+
+    it('should be able to add many helper patterns', function() {
+      this.command.run(this.fakeJasmine, ['--helper=helpers/**/*.js', '--helper=other.js']);
+      expect(this.fakeJasmine.addHelperFiles).toHaveBeenCalledWith(['helpers/**/*.js', 'other.js']);
+    });
+
+    it('should not modify helper patterns if no argument given', function() {
+      this.command.run(this.fakeJasmine, []);
+      expect(this.fakeJasmine.addHelperFiles).not.toHaveBeenCalled();
+    });
+
     it('should not configure stopping spec on expectation failure by default', function() {
       this.command.run(this.fakeJasmine, []);
       expect(this.fakeJasmine.stopSpecOnExpectationFailure).not.toHaveBeenCalled();

spec/jasmine_spec.js

@@ -40,6 +40,38 @@ describe('Jasmine', function() {
     expect(this.testJasmine.specFiles).toEqual(['some/file/path.js']);
   });
 
+  describe('file handler', function() {
+    function basename(name) { return path.basename(name); }
+
+    it('add spec files with absolute glob pattern', function() {
+      if (!path.isAbsolute) { return; }
+      var aFile = path.join(this.testJasmine.projectBaseDir, this.testJasmine.specDir, 'spec/command_spec.js');
+      expect(this.testJasmine.specFiles).toEqual([]);
+      this.testJasmine.addSpecFiles([aFile]);
+      expect(this.testJasmine.specFiles).toEqual([aFile]);
+    });
+
+    it('add spec files with glob pattern', function() {
+      expect(this.testJasmine.specFiles).toEqual([]);
+      this.testJasmine.addSpecFiles(['spec/*.js']);
+      expect(this.testJasmine.specFiles.map(basename)).toEqual(['command_spec.js', 'exit_spec.js', 'jasmine_spec.js']);
+    });
+
+    it('add spec files with glob pattern to existings files', function() {
+      var aFile = path.join(this.testJasmine.projectBaseDir, this.testJasmine.specDir, 'spec/command_spec.js');
+      this.testJasmine.specFiles = [aFile, 'b'];
+      this.testJasmine.addSpecFiles(['spec/*.js']);
+      expect(this.testJasmine.specFiles.map(basename)).toEqual(['command_spec.js', 'b', 'exit_spec.js', 'jasmine_spec.js']);
+    });
+
+    it('add helper files with glob pattern to existings files', function() {
+      var aFile = path.join(this.testJasmine.projectBaseDir, this.testJasmine.specDir, 'spec/command_spec.js');
+      this.testJasmine.helperFiles = [aFile, 'b'];
+      this.testJasmine.addHelperFiles(['spec/*.js']);
+      expect(this.testJasmine.helperFiles.map(basename)).toEqual(['command_spec.js', 'b', 'exit_spec.js', 'jasmine_spec.js']);
+    });
+  });
+
   it('delegates #coreVersion to jasmine-core', function() {
     this.fakeJasmineCore.version = jasmine.createSpy('coreVersion').and.returnValue('a version');
     expect(this.testJasmine.coreVersion()).toEqual('a version');