jcov 1.0.1 → 1.1

data/bin/jcov

@@ -13,6 +13,7 @@ global_option '--no-color', 'Disable color output'
 global_option '--no-coverage', 'Disable coverage output'
 global_option '--report', 'Report test coverage'
 global_option '--test REGEX', 'Limit the tests to only the ones that match the regular expression'
+global_option '--dump', 'Dump instrumented Javascript for debugging purposes'
 global_option '-c', '--config FILE', 'Specify a configuration file to use'
 
 default_command :run

data/examples/jasmine/javascripts/mean.js

@@ -9,3 +9,18 @@ Math.mean = function (array) {
 
   return sum / array.length;
 };
+
+var foo = function () {
+  // what
+  var x = 1;
+};
+
+// foo
+//   .bar
+//   .wibble()
+//   .baz();
+
+foo(function () {
+  // yes
+  var y = 1;
+});

data/features/coverage.feature

@@ -217,30 +217,25 @@ Feature: coverage
     And the output should not contain "FAIL"
     And the output should not contain "Total Coverage"
 
-
-  Scenario: functions should be reported as covered
+  Scenario: it handles syntax errors gracefully
     Given a file named "public/javascripts/foo.js" with:
     """
-    function foo() {
-      var bar = 0;
-    }
+    // yep
+    var bar = \foo;
     """
     When I run `jcov`
     Then the output should contain:
     """
-    Total Coverage: (1/2) 50.0%
+    error: Expecting Unicode escape sequence \uXXXX (2:11) in public/javascripts/foo.js
     """
 
-  Scenario: ignores comments
-    Given a file named "public/javascripts/foo.js" with:
+  Scenario: uncovered files with a syntax error should not cause a problem when loaded (Issue #3)
+    Given a file named "public/javascripts/notrun.js" with:
     """
-    // one
-    // two
-    var bar = 0;
-    // three
+    this will cause a syntax error because it's not actual javascript
     """
     When I run `jcov`
     Then the output should contain:
     """
-    Total Coverage: (1/1) 100.0%
+    error: Unexpected token (1:5) in public/javascripts/notrun.js
     """

data/features/html_report.feature

@@ -17,9 +17,9 @@ Feature: HTML Report
       }
     };
 
-    var three = function () {         // 6
+    function three() {                // 6
       two();                          // 7
-    };
+    }
 
     """
 
@@ -103,7 +103,7 @@ Feature: HTML Report
       | var one = "foo";          |
       | var z = 0;                |
       | var two = function () {   |
-      | var three = function () { |
+      | function three() {        |
 
   Scenario: see uncovered lines
     When I run `jcov --report`

data/features/instrumentation.feature

@@ -0,0 +1,310 @@
+Feature: instrumentation
+  In order to report coverage statistics
+  I need to instrument the running javascript
+
+  Background:
+    Given a file named "test/javascripts/runner.js" with:
+    """
+    load("public/javascripts/foo.js");
+    error_count = 0;
+    """
+
+  Scenario: it dumps instrumented file contents when a flag is set
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var bar = 0;
+    """
+    When I run `jcov --dump --trace`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var bar = 0;
+    """
+
+  Scenario: functions should be covered
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    function foo() {
+      var bar = 0;
+    }
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);function foo() {
+      _coverage_tick('public/javascripts/foo.js', 2);var bar = 0;
+    }
+    """
+
+  Scenario: ignores comments
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    // one
+    // two
+    var bar = 0;
+    // three
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    // one
+    // two
+    _coverage_tick('public/javascripts/foo.js', 3);var bar = 0;
+    // three
+    """
+
+  Scenario: it handles object definitions with function values
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var obj = {
+      foo: function () {
+        var test = 0;
+      }
+    };
+
+    obj.foo();
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var obj = {
+      foo: function () {
+        _coverage_tick('public/javascripts/foo.js', 3);var test = 0;
+      }
+    };
+
+    _coverage_tick('public/javascripts/foo.js', 7);obj.foo();
+    """
+
+  Scenario: it handles else if statements correctly
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    if (false) {
+      var one = 1;
+    }
+    else if (true) {
+      var two = 2;
+    }
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);if (false) {
+      _coverage_tick('public/javascripts/foo.js', 2);var one = 1;
+    }
+    else if (true) {
+      _coverage_tick('public/javascripts/foo.js', 5);var two = 2;
+    }
+    """
+
+  Scenario: it handles broken up if statements
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var foo = 3;
+    if (foo > 1 &&
+        foo < 8) {
+      var bar = 2;
+    }
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var foo = 3;
+    _coverage_tick('public/javascripts/foo.js', 2);if (foo > 1 &&
+        foo < 8) {
+      _coverage_tick('public/javascripts/foo.js', 4);var bar = 2;
+    }
+    """
+
+  Scenario: it handles weirdly formatted case statements
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var foo = 'bar';
+    switch (foo) {
+      case 'bar': wibble = 1;
+        break;
+      case 'baz': wibble = 2;
+        break;
+      default:
+        wibble = 3;
+    }
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var foo = 'bar';
+    _coverage_tick('public/javascripts/foo.js', 2);switch (foo) {
+      case 'bar': _coverage_tick('public/javascripts/foo.js', 3);wibble = 1;
+        _coverage_tick('public/javascripts/foo.js', 4);break;
+      case 'baz': _coverage_tick('public/javascripts/foo.js', 5);wibble = 2;
+        _coverage_tick('public/javascripts/foo.js', 6);break;
+      default:
+        _coverage_tick('public/javascripts/foo.js', 8);wibble = 3;
+    }
+    """
+
+  Scenario: it handles stupid formatting with grace
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var foo = 1
+      , bar = 2
+      , baz = function () { var wibble = 3; };
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var foo = 1
+      , bar = 2
+      , baz = function () { _coverage_tick('public/javascripts/foo.js', 3);var wibble = 3; };
+    """
+
+  Scenario: it still handles multiline functions within stupid formatting
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var foo = 1
+      , bar = 2
+      , baz = function () {
+          var wibble = 3;
+        };
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var foo = 1
+      , bar = 2
+      , baz = function () {
+          _coverage_tick('public/javascripts/foo.js', 4);var wibble = 3;
+        };
+    """
+
+  Scenario: it handles if..else statements without parens gracefully
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    if (foo)
+      bar = 1;
+    else
+      baz = 3;
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);if (foo)
+      bar = 1;
+    else
+      baz = 3;
+    """
+
+  Scenario: covers inline object definitions
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var foo = {bar:'baz'};
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var foo = {bar:'baz'};
+    """
+
+  Scenario: covers single line if statements
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    if (foo) bar();
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);if (foo) bar();
+    """
+
+  Scenario: handles catch statements
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    try {
+      foo();
+    }
+    catch(e) {
+      bar();
+    }
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);try {
+      _coverage_tick('public/javascripts/foo.js', 2);foo();
+    }
+    catch(e) {
+      _coverage_tick('public/javascripts/foo.js', 5);bar();
+    }
+    """
+
+  Scenario: ignores empty catch statements
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    try {
+      foo();
+    }
+    catch(e) {}
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);try {
+      _coverage_tick('public/javascripts/foo.js', 2);foo();
+    }
+    catch(e) {}
+    """
+
+  Scenario: ignores extra semicolons
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    try {
+      foo();
+    }
+    catch(e) {};
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);try {
+      _coverage_tick('public/javascripts/foo.js', 2);foo();
+    }
+    catch(e) {};
+    """
+
+  Scenario: handles mixed inline and non-inline variable declarations
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var foo, bar,
+        wibble = 'foo';
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var foo, bar,
+        wibble = 'foo';
+    """
+
+  Scenario: handles inline functions appropriately
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    var foo = function () { var bar = 0; };
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);var foo = function () { var bar = 0; };
+    """
+
+  Scenario: it handles for..in statements appropriately
+    Given a file named "public/javascripts/foo.js" with:
+    """
+    for (var i in foo) {
+      bar();
+    }
+    """
+    When I run `jcov --dump`
+    Then the output should contain:
+    """
+    _coverage_tick('public/javascripts/foo.js', 1);for (var i in foo) {
+      _coverage_tick('public/javascripts/foo.js', 2);bar();
+    }
+    """

data/features/javascript_interface.feature

@@ -70,3 +70,39 @@ Feature: javascript interface
     """
     here I am
     """
+
+  Scenario: I want to find where I made an error in my runner file
+    Given a file named "test/javascripts/runner.js" with:
+    """
+    // this is a comment
+    // this is another comment
+    var foo = 1;
+    var bar = 2;
+    var baz = 3;
+    fail();
+    """
+    When I run `jcov --trace`
+    Then the output should match:
+    """
+    test/javascripts/runner.js:6:\d+: fail is not defined
+    """
+
+  Scenario: I want to find where I made an error in tested Javascript
+    Given a file named "test/javascripts/runner.js" with:
+    """
+    load("public/javascripts/foo.js");
+    """
+    And a file named "public/javascripts/foo.js" with:
+    """
+    // this is a comment
+    // this is another comment
+    var foo = 1;
+    var bar = 2;
+    var baz = 3;
+    fail();
+    """
+    When I run `jcov --trace`
+    Then the output should match:
+    """
+    public/javascripts/foo.js:6:\d+: fail is not defined
+    """

data/features/run.feature

@@ -172,7 +172,7 @@ Feature: test runner
     Given a file named "test/javascripts/runner.js" with:
     """
     error_count = 0;
-    println(JCov.options.verbose);
+    println(JCov.config.verbose);
     """
     When I run `jcov --verbose`
     Then the output should contain:
@@ -184,7 +184,7 @@ Feature: test runner
     Given a file named "test/javascripts/runner.js" with:
     """
     error_count = 0;
-    println(JCov.options.color);
+    println(JCov.config.color);
     """
     When I run `jcov --no-color`
     Then the output should contain:
@@ -196,7 +196,7 @@ Feature: test runner
     Given a file named "test/javascripts/runner.js" with:
     """
     error_count = 0;
-    println(JCov.options.color);
+    println(JCov.config.color);
     """
     When I run `jcov --color`
     Then the output should contain:
@@ -208,10 +208,22 @@ Feature: test runner
     Given a file named "test/javascripts/runner.js" with:
     """
     error_count = 0;
-    println(JCov.options.color);
+    println(JCov.config.color);
     """
     When I run `jcov`
     Then the output should contain:
     """
     false
     """
+
+  Scenario: user can also use the old options object
+    Given a file named "test/javascripts/runner.js" with:
+    """
+    error_count = 0;
+    println(JCov.options.verbose);
+    """
+    When I run `jcov --verbose`
+    Then the output should contain:
+    """
+    true
+    """