Fixes #6. When an assertion is created but never executed, the test is marked as failed

Author: spadgos

Tyrtle.js

@@ -1,7 +1,7 @@
 /*!
  * Tyrtle - A JavaScript Unit Testing Framework
  *
- * Copyright (c) 2011 Nick Fisher
+ * Copyright (c) 2011-2012 Nick Fisher
  * Distributed under the terms of the LGPL
  * http://www.gnu.org/licenses/lgpl.html
  */
@@ -26,8 +26,9 @@
     setParams,
     root,
     runningInNode,
-    moduleAssertions = null, // the extra assertions added by an individual module
-    currentTestAssertions    // a counter for the number of assertions run in an individual test
+    unexecutedAssertions = 0, // the count of assertions created minus the number of assertions executed.
+    moduleAssertions = null,  // the extra assertions added by an individual module
+    currentTestAssertions     // a counter for the number of assertions run in an individual test
   ;
   // Gets the global object, regardless of whether run as ES3, ES5 or ES5 Strict Mode.
   root = (function () {
@@ -784,7 +785,7 @@
        *  @protected
        */
       run : function (callback) {
-        var start, success, handleError, test = this;
+        var start, success, handleError, test = this, originalUnexecutedAssertions;
         success = function () {
           test.runTime = new Date() - start;
           test.status = PASS;
@@ -812,28 +813,45 @@
             this.body(function (variables) {
               variables = variables || {};
               try {
-                currentTestAssertions = 0; // this is incremented by the `since` function
+                // this is incremented by the `since` function
+                currentTestAssertions = 0;
+
+                // remember how many unexecuted assertion there were at the start
+                originalUnexecutedAssertions = unexecutedAssertions;
                 test.asyncFn.call(variables, assert);
+
                 if (test.expectedAssertions !== -1) {
                   assert.that(currentTestAssertions)
                       .is(test.expectedAssertions)
                       .since("Incorrect number of assertions made by this test.")
                   ;
                 }
+                // check that no assertions were left unexecuted.
+                assert
+                  .that(unexecutedAssertions - originalUnexecutedAssertions)
+                  .is(0)
+                  .since("This test defines assertions which are never executed");
+
                 success();
               } catch (ee) {
                 handleError(ee);
               }
             });
           } else {
             currentTestAssertions = 0;
+            originalUnexecutedAssertions = unexecutedAssertions;
             this.body(assert);
             if (test.expectedAssertions !== -1) {
               assert.that(currentTestAssertions)
                   .is(test.expectedAssertions)
                   .since("Incorrect number of assertions made by this test.")
               ;
             }
+            // check that no assertions were left unexecuted.
+            assert
+              .that(unexecutedAssertions - originalUnexecutedAssertions)
+              .is(0)
+              .since("This test defines assertions which are never executed");
             success();
           }
         } catch (e) {
@@ -887,7 +905,10 @@
   //  Assertions  //
   //////////////////
   (function () {
-    var assertions, build, handleAssertionResult, internalAssertionCount = 0;
+    var assertions,
+        build,
+        handleAssertionResult,
+        internalAssertionCount = 0;
     assertions = {
       /**
        * Assert that two values are not identical. Uses strict equality checking: `!==`.
@@ -1273,18 +1294,25 @@
      */
     build = function (condition, message/*, args */) {
       var args = Array.prototype.slice.call(arguments, 2),
-        since
-      ;
+          since;
+      ++unexecutedAssertions;
       since = function (userMessage) {
         try {
           if (internalAssertionCount++ === 0) {
             ++currentTestAssertions;
           }
+          // if this is the first time we've executed this assertion, then decrease the counter, and don't count this
+          // one again
+          if (!since.executed) {
+            --unexecutedAssertions;
+            since.executed = true;
+          }
           handleAssertionResult(condition.apply(assert, args), args, message, userMessage);
         } finally {
           --internalAssertionCount;
         }
       };
+      since.executed = false;
       since.since = since;
       return since;
     };

demo/demo-tests.js

@@ -175,6 +175,12 @@
     this.test("endsWith 3", function (assert) {
       assert.that(123456).endsWith('456')();
     });
+    this.test("endsWith 4", function (assert) {
+      assert.that("123456").endsWith(456)();
+    });
+    this.test("This test forgets to execute an assertion", function (assert) {
+      assert.that(true).is(true);
+    });
   });
   tests.module("Demonstrating the variable logging (these should fail)", function () {
     this.test("Number, String", function (assert) {

test/assertions.js

@@ -568,7 +568,7 @@ asyncTest("Globally added assertions", function () {
   });
   t.run();
 });
-asyncTest("Assertion functions has access to other assertions via this", function () {
+asyncTest("Assertion functions have access to other assertions via this", function () {
   var t, passing = [], failing = [];
   t = new Tyrtle({
     callback : function () {
@@ -600,7 +600,7 @@ asyncTest("Assertion functions has access to other assertions via this", functio
     passing.push(this.test("passing", function (assert) {
       assert(true).globalA()("foo");
       assert(true).globalB()("foo");
-      assert(true).localA();
+      assert(true).localA()();
       assert('woo').globalToLocal()();
     }));
     failing.push(this.test("failing", function (assert) {
@@ -657,3 +657,30 @@ asyncTest("Assertions calling other assertions do not raise the expected count",
   });
   t.run();
 });
+
+asyncTest("Unexecuted assertions are treated as an error", function () {
+  var t, passing = [], failing = [];
+  t = new Tyrtle({
+    callback: function () {
+      equal(t.passes, passing.length, "Incorrect number of passes");
+      equal(t.fails, failing.length, "Incorrect number of failures");
+      start();
+    }
+  });
+  t.module("a", function () {
+    failing.push(this.test("doesn't execute an assertion", function (assert) {
+      assert.that(4).is(4);
+    }));
+    failing.push(this.test("one unexecuted, one executed twice", function (assert) {
+      assert.that(4).is(4);
+      var a = assert.that(2 + 2).is(4);
+      a();
+      a('still');
+    }));
+    passing.push(this.test("delayed execution", function (assert) {
+      var a = assert.that(2 + 2).is(4);
+      a();
+    }));
+  });
+  t.run();
+});