learn-test 1.1.0

data/lib/learn_test/jasmine/console.js

@@ -0,0 +1,161 @@
+/*
+Copyright (c) 2008-2013 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+function getJasmineRequireObj() {
+  if (typeof module !== "undefined" && module.exports) {
+    return exports;
+  } else {
+    window.jasmineRequire = window.jasmineRequire || {};
+    return window.jasmineRequire;
+  }
+}
+
+getJasmineRequireObj().console = function(jRequire, j$) {
+  j$.ConsoleReporter = jRequire.ConsoleReporter();
+};
+
+getJasmineRequireObj().ConsoleReporter = function() {
+
+  var noopTimer = {
+    start: function(){},
+    elapsed: function(){ return 0; }
+  };
+
+  function ConsoleReporter(options) {
+    var print = options.print,
+      showColors = options.showColors || false,
+      onComplete = options.onComplete || function() {},
+      timer = options.timer || noopTimer,
+      specCount,
+      failureCount,
+      failedSpecs = [],
+      pendingCount,
+      ansi = {
+        green: '\x1B[32m',
+        red: '\x1B[31m',
+        yellow: '\x1B[33m',
+        none: '\x1B[0m'
+      };
+
+    this.jasmineStarted = function() {
+      specCount = 0;
+      failureCount = 0;
+      pendingCount = 0;
+      print("Started");
+      printNewline();
+      timer.start();
+    };
+
+    this.jasmineDone = function() {
+      printNewline();
+      for (var i = 0; i < failedSpecs.length; i++) {
+        specFailureDetails(failedSpecs[i]);
+      }
+
+      printNewline();
+      var specCounts = specCount + " " + plural("spec", specCount) + ", " +
+        failureCount + " " + plural("failure", failureCount);
+
+      if (pendingCount) {
+        specCounts += ", " + pendingCount + " pending " + plural("spec", pendingCount);
+      }
+
+      print(specCounts);
+
+      printNewline();
+      var seconds = timer.elapsed() / 1000;
+      print("Finished in " + seconds + " " + plural("second", seconds));
+
+      printNewline();
+
+      onComplete(failureCount === 0);
+    };
+
+    this.specDone = function(result) {
+      specCount++;
+
+      if (result.status == "pending") {
+        pendingCount++;
+        print(colored("yellow", "*"));
+        return;
+      }
+
+      if (result.status == "passed") {
+        print(colored("green", '.'));
+        return;
+      }
+
+      if (result.status == "failed") {
+        failureCount++;
+        failedSpecs.push(result);
+        print(colored("red", 'F'));
+      }
+    };
+
+    return this;
+
+    function printNewline() {
+      print("\n");
+    }
+
+    function colored(color, str) {
+      return showColors ? (ansi[color] + str + ansi.none) : str;
+    }
+
+    function plural(str, count) {
+      return count == 1 ? str : str + "s";
+    }
+
+    function repeat(thing, times) {
+      var arr = [];
+      for (var i = 0; i < times; i++) {
+        arr.push(thing);
+      }
+      return arr;
+    }
+
+    function indent(str, spaces) {
+      var lines = (str || '').split("\n");
+      var newArr = [];
+      for (var i = 0; i < lines.length; i++) {
+        newArr.push(repeat(" ", spaces).join("") + lines[i]);
+      }
+      return newArr.join("\n");
+    }
+
+    function specFailureDetails(result) {
+      printNewline();
+      print(result.fullName);
+
+      for (var i = 0; i < result.failedExpectations.length; i++) {
+        var failedExpectation = result.failedExpectations[i];
+        printNewline();
+        print(indent(failedExpectation.stack, 2));
+      }
+
+      printNewline();
+    }
+  }
+
+  return ConsoleReporter;
+};
+

data/lib/learn_test/jasmine/formatters/jasmine2-junit.js

@@ -0,0 +1,199 @@
+(function() {
+    "use strict";
+
+    function getJasmineRequireObj() {
+        if (typeof module !== "undefined" && module.exports) {
+            return exports;
+        } else {
+            window.jasmineRequire = window.jasmineRequire || {};
+            return window.jasmineRequire;
+        }
+    }
+
+    if (typeof getJasmineRequireObj() == 'undefined') {
+        throw new Error("jasmine 2.0 must be loaded before jasmine-junit");
+    }
+
+    getJasmineRequireObj().JUnitXmlReporter = function() {
+
+
+        function JUnitXmlReporter(options) {
+            var runStartTime;
+            var specStartTime;
+            var suiteLevel = -1;
+            var suites = []
+            var currentSuite;
+            var totalNumberOfSpecs;
+            var totalNumberOfFailures;
+
+            this.jasmineStarted = function(started) {
+                totalNumberOfSpecs = started.totalSpecsDefined;
+                runStartTime = new Date();
+            };
+
+            this.jasmineDone = function() {
+                // console.log('Jasmine ran in ', elapsed(runStartTime, new Date()), ' seconds')
+                window.done = true
+            };
+
+            this.suiteStarted = function(result) {
+                suiteLevel++;
+                if (suiteLevel == 0) {
+                    totalNumberOfSpecs = 0;
+                    totalNumberOfFailures = 0;
+                    suites.push(result);
+                    currentSuite = result;
+                    currentSuite.startTime = new Date();
+                    currentSuite.noOfSpecs = 0;
+                    currentSuite.noOfFails = 0;
+                    currentSuite.specs = [];
+                }
+            };
+
+            this.suiteDone = function(result) {
+                if (suiteLevel == 0) {
+                    currentSuite.endTime = new Date();
+                    writeFile('.', descToFilename(result.description), suiteToJUnitXml(currentSuite))
+                }
+                suiteLevel--;
+            };
+
+            this.specStarted = function(result) {
+                specStartTime = new Date();
+            };
+
+            this.specDone = function(result) {
+                totalNumberOfSpecs++;
+
+                if (isFailed(result)) {
+                    currentSuite.noOfFails++;
+                }
+                result.startTime = specStartTime;
+                result.endTime = new Date();
+                currentSuite.specs.push(result);
+                currentSuite.noOfSpecs++;
+            };
+
+            return this;
+
+        }
+
+        return JUnitXmlReporter;
+    };
+
+    function isFailed(result) {
+        return result.status === 'failed'
+    }
+
+    function isSkipped(result) {
+        return result.status === 'pending'
+    }
+
+    function suiteToJUnitXml(suite) {
+        var resultXml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+        resultXml += '<testsuites>\n';
+        resultXml += '\t<testsuite tests="' + suite.noOfSpecs + '" errors="0" failures="' + suite.noOfFails + '" time="' + elapsed(suite.startTime, suite.endTime) + '" timestamp="' + ISODateString(suite.startTime) + '">\n'
+        for (var i = 0; i < suite.specs.length; i++) {
+            resultXml += specToJUnitXml(suite.specs[i], suite.description);
+        }
+        resultXml += '\t</testsuite>\n</testsuites>\n\n'
+        return resultXml;
+    }
+
+    function specToJUnitXml(spec, suiteId) {
+        var xml = '\t\t<testcase classname="' + suiteId +
+            '" name="' + escapeInvalidXmlChars(spec.fullName.replace(suiteId+" ", "")) + '" time="' + elapsed(spec.startTime, spec.endTime) + '">\n';
+        if (isSkipped(spec)) {
+            xml += '\t\t\t<skipped />\n';
+        }
+        if (isFailed(spec)) {
+            xml += failedToJUnitXml(spec.failedExpectations)
+        }
+        xml += '\t\t</testcase>\n'
+        return xml;
+    }
+
+    function failedToJUnitXml(failedExpectations) {
+        var failure;
+        var failureXml = ""
+        for (var i = 0; i < failedExpectations.length; i++) {
+            failure = failedExpectations[i];
+            failureXml += '\t\t\t<failure type="' + failure.matcherName + '" message="' + trim(escapeInvalidXmlChars(failure.message)) + '">\n';
+            failureXml += escapeInvalidXmlChars(failure.stack || failure.message);
+            failureXml += "\t\t\t</failure>\n";
+        }
+
+        return failureXml;
+    }
+
+    function descToFilename(desc) {
+        return 'TEST-' + desc + '.xml';
+    }
+
+    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 elapsed(startTime, endTime) {
+        return (endTime - startTime) / 1000;
+    }
+
+    function trim(str) {
+        return str.replace(/^\s+/, "").replace(/\s+$/, "");
+    }
+
+    function escapeInvalidXmlChars(str) {
+        return str.replace(/</g, "&lt;")
+            .replace(/\>/g, "&gt;")
+            .replace(/\"/g, "&quot;")
+            .replace(/\'/g, "&apos;")
+            .replace(/\&/g, "&amp;");
+    }
+
+    function writeFile(path, filename, text) {
+        function getQualifiedFilename(separator) {
+            if (path && path.substr(-1) !== separator && filename.substr(0) !== separator) {
+                path += separator;
+            }
+            return path + filename;
+        }
+
+        // PhantomJS
+        if(typeof(__phantom_writeFile) !== 'undefined') {
+            try {
+                // turn filename into a qualified path
+                filename = getQualifiedFilename(window.fs_path_separator);
+                // function injected by jasmine-runner.js
+                __phantom_writeFile(filename, text);
+                return;
+            } catch (error) {
+                console.log('Error writing file', error)
+            }
+        }
+
+        // Node.js
+        if(typeof(global) !== 'undefined') {
+            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 (error) {
+                console.log('Error writing file', error)
+            }
+        }
+    }
+
+})()
+

data/lib/learn_test/jasmine/helpers/ConsoleHelper.js

@@ -0,0 +1,12 @@
+if (navigator.userAgent.indexOf("PhantomJS") > 0) {
+  var consoleReporter = new jasmineRequire.ConsoleReporter()({
+    showColors: true,
+    timer: new jasmine.Timer,
+    print: function() {
+      console.log.apply(console, arguments)
+    }
+  });
+
+  jasmine.getEnv().addReporter(consoleReporter);
+}
+

data/lib/learn_test/jasmine/helpers/ConsoleHelperNoColor.js

@@ -0,0 +1,12 @@
+if (navigator.userAgent.indexOf("PhantomJS") > 0) {
+  var consoleReporter = new jasmineRequire.ConsoleReporter()({
+    showColors: false,
+    timer: new jasmine.Timer,
+    print: function() {
+      console.log.apply(console, arguments)
+    }
+  });
+
+  jasmine.getEnv().addReporter(consoleReporter);
+}
+

data/lib/learn_test/jasmine/initializer.rb

@@ -0,0 +1,27 @@
+module LearnTest
+  module Jasmine
+    class Initializer
+      def self.run
+        new.run
+      end
+
+      def run
+        make_spec_directory
+        generate_app_js
+      end
+
+      def make_spec_directory
+        FileUtils.mkdir_p('spec')
+        FileUtils.touch('spec/.keep')
+      end
+
+      def generate_app_js
+        FileUtils.cp(
+          "#{FileFinder.location_to_dir('templates')}/requires.yml.example",
+          'requires.yml'
+        )
+      end
+    end
+  end
+end
+

data/lib/learn_test/jasmine/jasmine-html.js

@@ -0,0 +1,360 @@
+/*
+Copyright (c) 2008-2013 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+jasmineRequire.html = function(j$) {
+  j$.ResultsNode = jasmineRequire.ResultsNode();
+  j$.HtmlReporter = jasmineRequire.HtmlReporter(j$);
+  j$.QueryString = jasmineRequire.QueryString();
+  j$.HtmlSpecFilter = jasmineRequire.HtmlSpecFilter();
+};
+
+jasmineRequire.HtmlReporter = function(j$) {
+
+  var noopTimer = {
+    start: function() {},
+    elapsed: function() { return 0; }
+  };
+
+  function HtmlReporter(options) {
+    var env = options.env || {},
+      getContainer = options.getContainer,
+      createElement = options.createElement,
+      createTextNode = options.createTextNode,
+      onRaiseExceptionsClick = options.onRaiseExceptionsClick || function() {},
+      timer = options.timer || noopTimer,
+      results = [],
+      specsExecuted = 0,
+      failureCount = 0,
+      pendingSpecCount = 0,
+      htmlReporterMain,
+      symbols;
+
+    this.initialize = function() {
+      htmlReporterMain = createDom("div", {className: "html-reporter"},
+        createDom("div", {className: "banner"},
+          createDom("span", {className: "title"}, "Jasmine"),
+          createDom("span", {className: "version"}, j$.version)
+        ),
+        createDom("ul", {className: "symbol-summary"}),
+        createDom("div", {className: "alert"}),
+        createDom("div", {className: "results"},
+          createDom("div", {className: "failures"})
+        )
+      );
+      getContainer().appendChild(htmlReporterMain);
+
+      symbols = find(".symbol-summary");
+    };
+
+    var totalSpecsDefined;
+    this.jasmineStarted = function(options) {
+      totalSpecsDefined = options.totalSpecsDefined || 0;
+      timer.start();
+    };
+
+    var summary = createDom("div", {className: "summary"});
+
+    var topResults = new j$.ResultsNode({}, "", null),
+      currentParent = topResults;
+
+    this.suiteStarted = function(result) {
+      currentParent.addChild(result, "suite");
+      currentParent = currentParent.last();
+    };
+
+    this.suiteDone = function(result) {
+      if (currentParent == topResults) {
+        return;
+      }
+
+      currentParent = currentParent.parent;
+    };
+
+    this.specStarted = function(result) {
+      currentParent.addChild(result, "spec");
+    };
+
+    var failures = [];
+    this.specDone = function(result) {
+      if (result.status != "disabled") {
+        specsExecuted++;
+      }
+
+      symbols.appendChild(createDom("li", {
+          className: result.status,
+          id: "spec_" + result.id,
+          title: result.fullName
+        }
+      ));
+
+      if (result.status == "failed") {
+        failureCount++;
+
+        var failure =
+          createDom("div", {className: "spec-detail failed"},
+            createDom("div", {className: "description"},
+              createDom("a", {title: result.fullName, href: specHref(result)}, result.fullName)
+            ),
+            createDom("div", {className: "messages"})
+          );
+        var messages = failure.childNodes[1];
+
+        for (var i = 0; i < result.failedExpectations.length; i++) {
+          var expectation = result.failedExpectations[i];
+          messages.appendChild(createDom("div", {className: "result-message"}, expectation.message));
+          messages.appendChild(createDom("div", {className: "stack-trace"}, expectation.stack));
+        }
+
+        failures.push(failure);
+      }
+
+      if (result.status == "pending") {
+        pendingSpecCount++;
+      }
+    };
+
+    this.jasmineDone = function() {
+      var banner = find(".banner");
+      banner.appendChild(createDom("span", {className: "duration"}, "finished in " + timer.elapsed() / 1000 + "s"));
+
+      var alert = find(".alert");
+
+      alert.appendChild(createDom("span", { className: "exceptions" },
+        createDom("label", { className: "label", 'for': "raise-exceptions" }, "raise exceptions"),
+        createDom("input", {
+          className: "raise",
+          id: "raise-exceptions",
+          type: "checkbox"
+        })
+      ));
+      var checkbox = find("input");
+
+      checkbox.checked = !env.catchingExceptions();
+      checkbox.onclick = onRaiseExceptionsClick;
+
+      if (specsExecuted < totalSpecsDefined) {
+        var skippedMessage = "Ran " + specsExecuted + " of " + totalSpecsDefined + " specs - run all";
+        alert.appendChild(
+          createDom("span", {className: "bar skipped"},
+            createDom("a", {href: "?", title: "Run all specs"}, skippedMessage)
+          )
+        );
+      }
+      var statusBarMessage = "" + pluralize("spec", specsExecuted) + ", " + pluralize("failure", failureCount);
+      if (pendingSpecCount) { statusBarMessage += ", " + pluralize("pending spec", pendingSpecCount); }
+
+      var statusBarClassName = "bar " + ((failureCount > 0) ? "failed" : "passed");
+      alert.appendChild(createDom("span", {className: statusBarClassName}, statusBarMessage));
+
+      var results = find(".results");
+      results.appendChild(summary);
+
+      summaryList(topResults, summary);
+
+      function summaryList(resultsTree, domParent) {
+        var specListNode;
+        for (var i = 0; i < resultsTree.children.length; i++) {
+          var resultNode = resultsTree.children[i];
+          if (resultNode.type == "suite") {
+            var suiteListNode = createDom("ul", {className: "suite", id: "suite-" + resultNode.result.id},
+              createDom("li", {className: "suite-detail"},
+                createDom("a", {href: specHref(resultNode.result)}, resultNode.result.description)
+              )
+            );
+
+            summaryList(resultNode, suiteListNode);
+            domParent.appendChild(suiteListNode);
+          }
+          if (resultNode.type == "spec") {
+            if (domParent.getAttribute("class") != "specs") {
+              specListNode = createDom("ul", {className: "specs"});
+              domParent.appendChild(specListNode);
+            }
+            specListNode.appendChild(
+              createDom("li", {
+                  className: resultNode.result.status,
+                  id: "spec-" + resultNode.result.id
+                },
+                createDom("a", {href: specHref(resultNode.result)}, resultNode.result.description)
+              )
+            );
+          }
+        }
+      }
+
+      if (failures.length) {
+        alert.appendChild(
+          createDom('span', {className: "menu bar spec-list"},
+            createDom("span", {}, "Spec List | "),
+            createDom('a', {className: "failures-menu", href: "#"}, "Failures")));
+        alert.appendChild(
+          createDom('span', {className: "menu bar failure-list"},
+            createDom('a', {className: "spec-list-menu", href: "#"}, "Spec List"),
+            createDom("span", {}, " | Failures ")));
+
+        find(".failures-menu").onclick = function() {
+          setMenuModeTo('failure-list');
+        };
+        find(".spec-list-menu").onclick = function() {
+          setMenuModeTo('spec-list');
+        };
+
+        setMenuModeTo('failure-list');
+
+        var failureNode = find(".failures");
+        for (var i = 0; i < failures.length; i++) {
+          failureNode.appendChild(failures[i]);
+        }
+      }
+    };
+
+    return this;
+
+    function find(selector) {
+      return getContainer().querySelector(selector);
+    }
+
+    function createDom(type, attrs, childrenVarArgs) {
+      var el = createElement(type);
+
+      for (var i = 2; i < arguments.length; i++) {
+        var child = arguments[i];
+
+        if (typeof child === 'string') {
+          el.appendChild(createTextNode(child));
+        } else {
+          if (child) {
+            el.appendChild(child);
+          }
+        }
+      }
+
+      for (var attr in attrs) {
+        if (attr == "className") {
+          el[attr] = attrs[attr];
+        } else {
+          el.setAttribute(attr, attrs[attr]);
+        }
+      }
+
+      return el;
+    }
+
+    function pluralize(singular, count) {
+      var word = (count == 1 ? singular : singular + "s");
+
+      return "" + count + " " + word;
+    }
+
+    function specHref(result) {
+      return "?spec=" + encodeURIComponent(result.fullName);
+    }
+
+    function setMenuModeTo(mode) {
+      htmlReporterMain.setAttribute("class", "html-reporter " + mode);
+    }
+  }
+
+  return HtmlReporter;
+};
+
+jasmineRequire.HtmlSpecFilter = function() {
+  function HtmlSpecFilter(options) {
+    var filterString = options && options.filterString() && options.filterString().replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var filterPattern = new RegExp(filterString);
+
+    this.matches = function(specName) {
+      return filterPattern.test(specName);
+    };
+  }
+
+  return HtmlSpecFilter;
+};
+
+jasmineRequire.ResultsNode = function() {
+  function ResultsNode(result, type, parent) {
+    this.result = result;
+    this.type = type;
+    this.parent = parent;
+
+    this.children = [];
+
+    this.addChild = function(result, type) {
+      this.children.push(new ResultsNode(result, type, this));
+    };
+
+    this.last = function() {
+      return this.children[this.children.length - 1];
+    };
+  }
+
+  return ResultsNode;
+};
+
+jasmineRequire.QueryString = function() {
+  function QueryString(options) {
+
+    this.setParam = function(key, value) {
+      var paramMap = queryStringToParamMap();
+      paramMap[key] = value;
+      options.getWindowLocation().search = toQueryString(paramMap);
+    };
+
+    this.getParam = function(key) {
+      return queryStringToParamMap()[key];
+    };
+
+    return this;
+
+    function toQueryString(paramMap) {
+      var qStrPairs = [];
+      for (var prop in paramMap) {
+        qStrPairs.push(encodeURIComponent(prop) + "=" + encodeURIComponent(paramMap[prop]));
+      }
+      return "?" + qStrPairs.join('&');
+    }
+
+    function queryStringToParamMap() {
+      var paramStr = options.getWindowLocation().search.substring(1),
+        params = [],
+        paramMap = {};
+
+      if (paramStr.length > 0) {
+        params = paramStr.split('&');
+        for (var i = 0; i < params.length; i++) {
+          var p = params[i].split('=');
+          var value = decodeURIComponent(p[1]);
+          if (value === "true" || value === "false") {
+            value = JSON.parse(value);
+          }
+          paramMap[decodeURIComponent(p[0])] = value;
+        }
+      }
+
+      return paramMap;
+    }
+
+  }
+
+  return QueryString;
+};
+