guard-jasmine 1.3.0 → 1.19.2

data/lib/guard/jasmine/phantomjs/guard-jasmine.js

@@ -0,0 +1,246 @@
+(function() {
+  var currentSpecId, errors, fs, getXmlResults, jasmineAvailable, jasmineMissing, jasmineReady, logs, options, overloadPageEvaluate, page, replaceFunctionPlaceholders, resultsKey, setupWriteFileFunction, specsDone, specsReady, specsTimedout, waitFor;
+
+  phantom.injectJs('lib/result.js');
+
+  options = {
+    url: phantom.args[0] || 'http://127.0.0.1:3000/jasmine',
+    timeout: parseInt(phantom.args[1] || 10000),
+    specdoc: phantom.args[2] || 'failure',
+    focus: /true/i.test(phantom.args[3]),
+    console: phantom.args[4] || 'failure',
+    errors: phantom.args[5] || 'failure',
+    junit: /true/i.test(phantom.args[6]),
+    junit_consolidate: /true/i.test(phantom.args[7]),
+    junit_save_path: phantom.args[8] || ''
+  };
+
+  page = require('webpage').create();
+
+  currentSpecId = -1;
+
+  logs = {};
+
+  errors = {};
+
+  resultsKey = "__jr" + Math.ceil(Math.random() * 1000000);
+
+  fs = require("fs");
+
+  page.onError = function(msg, trace) {
+    if (currentSpecId) {
+      errors[currentSpecId] || (errors[currentSpecId] = []);
+      return errors[currentSpecId].push({
+        msg: msg,
+        trace: trace
+      });
+    }
+  };
+
+  page.onConsoleMessage = function(msg, line, source) {
+    var result;
+
+    if (/^RUNNER_END$/.test(msg)) {
+      result = page.evaluate(function() {
+        return window.reporter.runnerResult;
+      });
+      console.log(JSON.stringify(new Result(result, logs, errors, options).process()));
+      return page.evaluate(function() {
+        return window.resultReceived = true;
+      });
+    } else if (/^SPEC_START: (\d+)$/.test(msg)) {
+      return currentSpecId = Number(RegExp.$1);
+    } else {
+      logs[currentSpecId] || (logs[currentSpecId] = []);
+      return logs[currentSpecId].push(msg);
+    }
+  };
+
+  page.onInitialized = function() {
+    var setupReporters;
+
+    overloadPageEvaluate(page);
+    setupWriteFileFunction(page, resultsKey, fs.separator);
+    page.injectJs('lib/console.js');
+    page.injectJs('lib/reporter.js');
+    page.injectJs('lib/junit_reporter.js');
+    setupReporters = function() {
+      return window.onload = function() {
+        window.onload = null;
+        window.resultReceived = false;
+        window.reporter = new ConsoleReporter();
+        if (window.jasmine) {
+          jasmine.getEnv().addReporter(new JUnitXmlReporter("%save_path%", "%consolidate%"));
+          return jasmine.getEnv().addReporter(window.reporter);
+        }
+      };
+    };
+    return page.evaluate(setupReporters, {
+      save_path: options.junit_save_path,
+      consolidate: options.junit_consolidate
+    });
+  };
+
+  getXmlResults = function(page, key) {
+    var getWindowObj;
+
+    getWindowObj = function() {
+      return window["%resultsObj%"] || {};
+    };
+    return page.evaluate(getWindowObj, {
+      resultsObj: key
+    });
+  };
+
+  replaceFunctionPlaceholders = function(fn, replacements) {
+    var match, p;
+
+    if (replacements && typeof replacements === 'object') {
+      fn = fn.toString();
+      for (p in replacements) {
+        if (replacements.hasOwnProperty(p)) {
+          match = new RegExp("%" + p + "%", "g");
+          while (true) {
+            fn = fn.replace(match, replacements[p]);
+            if (fn.indexOf(match) === -1) {
+              break;
+            }
+          }
+        }
+      }
+    }
+    return fn;
+  };
+
+  overloadPageEvaluate = function(page) {
+    page._evaluate = page.evaluate;
+    page.evaluate = function(fn, replacements) {
+      return page._evaluate(replaceFunctionPlaceholders(fn, replacements));
+    };
+    return page;
+  };
+
+  setupWriteFileFunction = function(page, key, path_separator) {
+    var saveData;
+
+    saveData = function() {
+      window["%resultsObj%"] = {};
+      window.fs_path_separator = "%fs_path_separator%";
+      return window.__phantom_writeFile = function(filename, text) {
+        return window["%resultsObj%"][filename] = text;
+      };
+    };
+    return page.evaluate(saveData, {
+      resultsObj: key,
+      fs_path_separator: path_separator
+    });
+  };
+
+  page.open(options.url, function(status) {
+    page.onLoadFinished = function() {};
+    if (status !== 'success') {
+      console.log(JSON.stringify({
+        error: "Unable to access Jasmine specs at " + options.url
+      }));
+      return phantom.exit();
+    } else {
+      return waitFor(jasmineReady, jasmineAvailable, options.timeout, jasmineMissing);
+    }
+  });
+
+  jasmineReady = function() {
+    return page.evaluate(function() {
+      return window.jasmine;
+    });
+  };
+
+  jasmineAvailable = function() {
+    return waitFor(specsReady, specsDone, options.timeout, specsTimedout);
+  };
+
+  jasmineMissing = function() {
+    var error, text;
+
+    text = page.evaluate(function() {
+      var _ref;
+
+      return (_ref = document.getElementsByTagName('body')[0]) != null ? _ref.innerText : void 0;
+    });
+    if (text) {
+      error = "The Jasmine reporter is not available!\n\n" + text;
+      return console.log(JSON.stringify({
+        error: error
+      }));
+    } else {
+      return console.log(JSON.stringify({
+        error: 'The Jasmine reporter is not available!'
+      }));
+    }
+  };
+
+  specsReady = function() {
+    return page.evaluate(function() {
+      return window.resultReceived;
+    });
+  };
+
+  specsTimedout = function() {
+    var error, text;
+
+    text = page.evaluate(function() {
+      var _ref;
+
+      return (_ref = document.getElementsByTagName('body')[0]) != null ? _ref.innerText : void 0;
+    });
+    if (text) {
+      error = "Timeout waiting for the Jasmine test results!\n\n" + text;
+      return console.log(JSON.stringify({
+        error: error
+      }));
+    } else {
+      return console.log(JSON.stringify({
+        error: 'Timeout for the Jasmine test results!'
+      }));
+    }
+  };
+
+  specsDone = function() {
+    var filename, output, xml_results;
+
+    if (options.junit === true) {
+      xml_results = getXmlResults(page, resultsKey);
+      for (filename in xml_results) {
+        if (xml_results.hasOwnProperty(filename) && (output = xml_results[filename]) && typeof output === 'string') {
+          fs.write(filename, output, 'w');
+        }
+      }
+    }
+    return phantom.exit();
+  };
+
+  waitFor = function(test, ready, timeout, timeoutFunction) {
+    var condition, interval, start, wait;
+
+    if (timeout == null) {
+      timeout = 10000;
+    }
+    start = Date.now();
+    condition = false;
+    interval = void 0;
+    wait = function() {
+      if ((Date.now() - start < timeout) && !condition) {
+        return condition = test();
+      } else {
+        clearInterval(interval);
+        if (condition) {
+          return ready();
+        } else {
+          timeoutFunction();
+          return phantom.exit(1);
+        }
+      }
+    };
+    return interval = setInterval(wait, 250);
+  };
+
+}).call(this);

data/lib/guard/jasmine/phantomjs/lib/console.js

@@ -3,32 +3,37 @@
     __slice = [].slice;
 
   Console = (function() {
-
     function Console(console) {
       var log;
+
       log = console.log;
       console.log = function() {
         var args;
+
         args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
         return log.call(console, Console.format.apply(Console, args));
       };
       console.info = function() {
         var args;
+
         args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
         return log.call(console, "INFO: " + (Console.format.apply(Console, args)));
       };
       console.warn = function() {
         var args;
+
         args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
         return log.call(console, "WARN: " + (Console.format.apply(Console, args)));
       };
       console.error = function() {
         var args;
+
         args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
         return log.call(console, "ERROR: " + (Console.format.apply(Console, args)));
       };
       console.debug = function() {
         var args;
+
         args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
         return log.call(console, "DEBUG: " + (Console.format.apply(Console, args)));
       };
@@ -39,6 +44,7 @@
     Console.format = function() {
       var arg, args, result, _i, _len,
         _this = this;
+
       args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
       result = [];
       if (typeof args[0] === 'string' && /%[sdifo]/gi.test(args[0])) {
@@ -56,6 +62,7 @@
 
     Console.inspect = function(object, type) {
       var match, result;
+
       switch (type) {
         case '%s':
           result = String(object);
@@ -93,6 +100,7 @@
 
     Console.pp = function(object, depth) {
       var key, result, type, value, _i, _len;
+
       if (depth == null) {
         depth = 0;
       }

data/lib/guard/jasmine/phantomjs/lib/junit_reporter.js

@@ -0,0 +1,224 @@
+(function() {
+    function elapsed(startTime, endTime) {
+        return (endTime - startTime)/1000;
+    }
+
+    function ISODateString(d) {
+        function pad(n) { return n < 10 ? '0'+n : n; }
+
+        return d.getFullYear() + '-' +
+            pad(d.getMonth()+1) + '-' +
+            pad(d.getDate()) + 'T' +
+            pad(d.getHours()) + ':' +
+            pad(d.getMinutes()) + ':' +
+            pad(d.getSeconds());
+    }
+
+    function trim(str) {
+        return str.replace(/^\s+/, "" ).replace(/\s+$/, "" );
+    }
+
+    function escapeInvalidXmlChars(str) {
+        return str.replace(/\&/g, "&amp;")
+            .replace(/</g, "&lt;")
+            .replace(/\>/g, "&gt;")
+            .replace(/\"/g, "&quot;")
+            .replace(/\'/g, "&apos;");
+    }
+
+    /**
+     * Generates JUnit XML for the given spec run.
+     * Allows the test results to be used in java based CI
+     * systems like CruiseControl and Hudson.
+     *
+     * @param {string} savePath where to save the files
+     * @param {boolean} consolidate whether to save nested describes within the
+     *                  same file as their parent; default: true
+     * @param {boolean} useDotNotation whether to separate suite names with
+     *                  dots rather than spaces (ie "Class.init" not
+     *                  "Class init"); default: true
+     */
+    var JUnitXmlReporter = function(savePath, consolidate, useDotNotation) {
+        this.savePath = savePath || '';
+        this.consolidate = consolidate === jasmine.undefined ? true : consolidate;
+        this.useDotNotation = useDotNotation === jasmine.undefined ? true : useDotNotation;
+    };
+    JUnitXmlReporter.finished_at = null; // will be updated after all files have been written
+
+    JUnitXmlReporter.prototype = {
+        reportSpecStarting: function(spec) {
+            spec.startTime = new Date();
+
+            if (!spec.suite.startTime) {
+                spec.suite.startTime = spec.startTime;
+            }
+        },
+
+        reportSpecResults: function(spec) {
+            var results = spec.results();
+            spec.didFail = !results.passed();
+            spec.duration = elapsed(spec.startTime, new Date());
+            spec.output = '<testcase classname="' + this.getFullName(spec.suite) +
+                '" name="' + escapeInvalidXmlChars(spec.description) + '" time="' + spec.duration + '">';
+            if(results.skipped) {
+              spec.output = spec.output + "<skipped />";
+            }
+
+            var failure = "";
+            var failures = 0;
+            var resultItems = results.getItems();
+            for (var i = 0; i < resultItems.length; i++) {
+                var result = resultItems[i];
+
+                if (result.type == 'expect' && result.passed && !result.passed()) {
+                    failures += 1;
+                    failure += '<failure type="' + result.type + '" message="' + trim(escapeInvalidXmlChars(result.message)) + '">';
+                    failure += escapeInvalidXmlChars(result.trace.stack || result.message);
+                    failure += "</failure>";
+                }
+            }
+            if (failure) {
+                spec.output += failure;
+            }
+            spec.output += "</testcase>";
+        },
+
+        reportSuiteResults: function(suite) {
+            var results = suite.results();
+            var specs = suite.specs();
+            var specOutput = "";
+            // for JUnit results, let's only include directly failed tests (not nested suites')
+            var failedCount = 0;
+
+            suite.status = results.passed() ? 'Passed.' : 'Failed.';
+            if (results.totalCount === 0) { // todo: change this to check results.skipped
+                suite.status = 'Skipped.';
+            }
+
+            // if a suite has no (active?) specs, reportSpecStarting is never called
+            // and thus the suite has no startTime -- account for that here
+            suite.startTime = suite.startTime || new Date();
+            suite.duration = elapsed(suite.startTime, new Date());
+
+            for (var i = 0; i < specs.length; i++) {
+                failedCount += specs[i].didFail ? 1 : 0;
+                specOutput += "\n  " + specs[i].output;
+            }
+            suite.output = '\n<testsuite name="' + this.getFullName(suite) +
+                '" errors="0" tests="' + specs.length + '" failures="' + failedCount +
+                '" time="' + suite.duration + '" timestamp="' + ISODateString(suite.startTime) + '">';
+            suite.output += specOutput;
+            suite.output += "\n</testsuite>";
+        },
+
+        reportRunnerResults: function(runner) {
+            var suites = runner.suites();
+            for (var i = 0; i < suites.length; i++) {
+                var suite = suites[i];
+                var fileName = 'TEST-' + this.getFullName(suite, true) + '.xml';
+                var output = '<?xml version="1.0" encoding="UTF-8" ?>';
+                // if we are consolidating, only write out top-level suites
+                if (this.consolidate && suite.parentSuite) {
+                    continue;
+                }
+                else if (this.consolidate) {
+                    output += "\n<testsuites>";
+                    output += this.getNestedOutput(suite);
+                    output += "\n</testsuites>";
+                    this.writeFile(this.savePath, fileName, output);
+                }
+                else {
+                    output += suite.output;
+                    this.writeFile(this.savePath, fileName, output);
+                }
+            }
+            // When all done, make it known on JUnitXmlReporter
+            JUnitXmlReporter.finished_at = (new Date()).getTime();
+        },
+
+        getNestedOutput: function(suite) {
+            var output = suite.output;
+            for (var i = 0; i < suite.suites().length; i++) {
+                output += this.getNestedOutput(suite.suites()[i]);
+            }
+            return output;
+        },
+
+        writeFile: function(path, filename, text) {
+            function getQualifiedFilename(separator) {
+                if (path && path.substr(-1) !== separator && filename.substr(0) !== separator) {
+                    path += separator;
+                }
+                return path + filename;
+            }
+
+            // Rhino
+            try {
+                // turn filename into a qualified path
+                if (path) {
+                    filename = getQualifiedFilename(java.lang.System.getProperty("file.separator"));
+                    // create parent dir and ancestors if necessary
+                    var file = java.io.File(filename);
+                    var parentDir = file.getParentFile();
+                    if (!parentDir.exists()) {
+                        parentDir.mkdirs();
+                    }
+                }
+                // finally write the file
+                var out = new java.io.BufferedWriter(new java.io.FileWriter(filename));
+                out.write(text);
+                out.close();
+                return;
+            } catch (e) {}
+            // PhantomJS, via a method injected by phantomjs-testrunner.js
+            try {
+                // turn filename into a qualified path
+                filename = getQualifiedFilename(window.fs_path_separator);
+                __phantom_writeFile(filename, text);
+                return;
+            } catch (f) {}
+            // Node.js
+            try {
+                var fs = require("fs");
+                var nodejs_path = require("path");
+                var fd = fs.openSync(nodejs_path.join(path, filename), "w");
+                fs.writeSync(fd, text, 0);
+                fs.closeSync(fd);
+                return;
+            } catch (g) {}
+        },
+
+        getFullName: function(suite, isFilename) {
+            var fullName;
+            if (this.useDotNotation) {
+                fullName = suite.description;
+                for (var parentSuite = suite.parentSuite; parentSuite; parentSuite = parentSuite.parentSuite) {
+                    fullName = parentSuite.description + '.' + fullName;
+                }
+            }
+            else {
+                fullName = suite.getFullName();
+            }
+
+            // Either remove or escape invalid XML characters
+            if (isFilename) {
+                return fullName.replace(/[^\w]/g, "");
+            }
+            return escapeInvalidXmlChars(fullName);
+        },
+
+        log: function(str) {
+            var console = jasmine.getGlobal().console;
+
+            if (console && console.log) {
+                console.log(str);
+            }
+        }
+    };
+
+    if (typeof module !== 'undefined' && module.exports) {
+      module.exports = JUnitXmlReporter;
+    } else {
+      window.JUnitXmlReporter = JUnitXmlReporter;
+    }
+}).call(this);

data/lib/guard/jasmine/phantomjs/lib/reporter.js

@@ -2,7 +2,6 @@
   var ConsoleReporter;
 
   ConsoleReporter = (function() {
-
     function ConsoleReporter() {}
 
     ConsoleReporter.prototype.runnerResult = {
@@ -27,10 +26,11 @@
 
     ConsoleReporter.prototype.reportSpecResults = function(spec) {
       var messages, result, specResult, _base, _i, _len, _name, _ref;
+
       if (!spec.results().skipped) {
         specResult = {
           id: spec.id,
-          description: spec.description,
+          description: '' + spec.description,
           passed: spec.results().failedCount === 0
         };
         if (spec.results().failedCount !== 0) {
@@ -52,11 +52,12 @@
 
     ConsoleReporter.prototype.reportSuiteResults = function(suite) {
       var parent, suiteResult, _base, _ref;
+
       if (!suite.results().skipped) {
         suiteResult = {
           id: suite.id,
           parent: (_ref = suite.parentSuite) != null ? _ref.id : void 0,
-          description: suite.description,
+          description: '' + suite.description,
           passed: suite.results().failedCount === 0,
           specs: this.currentSpecs[suite.id] || [],
           suites: []
@@ -77,6 +78,7 @@
 
     ConsoleReporter.prototype.reportRunnerResults = function(runner) {
       var end, runtime;
+
       runtime = (new Date().getTime() - this.startTime) / 1000;
       this.runnerResult['passed'] = runner.results().failedCount === 0;
       this.runnerResult['stats'] = {
@@ -84,6 +86,9 @@
         failures: runner.results().failedCount,
         time: runtime
       };
+      if (window.__coverage__) {
+        this.runnerResult['coverage'] = window.__coverage__;
+      }
       end = function() {
         return console.log("RUNNER_END");
       };
@@ -96,6 +101,7 @@
 
     ConsoleReporter.prototype.addNestedSuites = function(suiteResult) {
       var suite, _i, _len, _ref, _results;
+
       if (this.nestedSuiteResults[suiteResult.id]) {
         _ref = this.nestedSuiteResults[suiteResult.id];
         _results = [];
@@ -110,6 +116,7 @@
 
     ConsoleReporter.prototype.removeEmptySuites = function(suiteResult) {
       var suite, suites, _i, _len, _ref;
+
       suites = [];
       _ref = suiteResult.suites;
       for (_i = 0, _len = _ref.length; _i < _len; _i++) {

data/lib/guard/jasmine/phantomjs/lib/result.js

@@ -2,7 +2,6 @@
   var Result;
 
   Result = (function() {
-
     function Result(result, logs, errors, options) {
       this.result = result;
       this.logs = logs != null ? logs : {};
@@ -12,8 +11,10 @@
 
     Result.prototype.addLogs = function(suite) {
       var id, s, spec;
+
       suite.suites = (function() {
         var _i, _len, _ref, _results;
+
         _ref = suite.suites;
         _results = [];
         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -25,6 +26,7 @@
       if (suite.specs) {
         suite.specs = (function() {
           var _i, _len, _ref, _results;
+
           _ref = suite.specs;
           _results = [];
           for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -45,8 +47,10 @@
 
     Result.prototype.addErrors = function(suite) {
       var id, s, spec;
+
       suite.suites = (function() {
         var _i, _len, _ref, _results;
+
         _ref = suite.suites;
         _results = [];
         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -58,6 +62,7 @@
       if (suite.specs) {
         suite.specs = (function() {
           var _i, _len, _ref, _results;
+
           _ref = suite.specs;
           _results = [];
           for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -76,10 +81,31 @@
       return suite;
     };
 
+    Result.prototype.addGlobalError = function(suite) {
+      var b, err, errMsg, globalErrors, noSpecs, noSuites, _i, _len, _ref;
+
+      noSuites = !suite.suites || suite.suites.length === 0;
+      noSpecs = !suite.specs || suite.specs.length === 0;
+      globalErrors = this.errors[-1] && this.errors[-1].length !== 0;
+      if (noSuites && noSpecs && globalErrors) {
+        err = this.errors[-1][0];
+        errMsg = [err.msg];
+        _ref = err.trace;
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          b = _ref[_i];
+          errMsg.push("\n  " + b.file + ":" + b.line + " " + b["function"]);
+        }
+        suite.error = errMsg.join("");
+        return suite.passed = false;
+      }
+    };
+
     Result.prototype.cleanResult = function(suite) {
       var s, spec, _i, _len, _ref;
+
       suite.suites = (function() {
         var _i, _len, _ref, _results;
+
         _ref = suite.suites;
         _results = [];
         for (_i = 0, _len = _ref.length; _i < _len; _i++) {
@@ -106,6 +132,7 @@
       }
       if (this.options.errors !== 'never') {
         this.addErrors(this.result);
+        this.addGlobalError(this.result);
       }
       this.cleanResult(this.result);
       return this.result;