a_mock 1.0.5 → 2.0.1

package/newThenSpec/testExecute.js

@@ -1,80 +1,80 @@
-var assert = require('assert');
-var test = require('../test');
-var mock = require('../partialMock/simple/newMock');
-
-(function() {
-	console.log('execute with no args');
-
-    var isResolved;
-
-    var newPromise = require('../newThen')();
-    var p = newPromise();
-
-    p.then(function() {
-        isResolved = true;
-    });
-
-    test('returns resolved promise', function() {
-        assert.ok(isResolved);
-    });
-
-})();
-
-
-(function() {
-	console.log('execute with 1 arg');
-
-    var returned;
-    var valueToResolveWith = {};
-
-    var newPromise = require('../newThen')();
-    var p = newPromise(valueToResolveWith);
-
-    p.then(function(result) {
-        returned = result;
-    });
-
-    test('returns promise resolved with the given arg', function() {
-        assert.strictEqual(valueToResolveWith, returned);
-    });
-
-})();
-
-(function() {
-	console.log('execute with 2 args');
-
-    var returned;
-    var valueToResolveWith = {};
-    var errorToRejectWith = {};
-
-    var newPromise = require('../newThen')();
-    var p = newPromise(valueToResolveWith, errorToRejectWith);
-
-    p.then(function(result) {
-        returned = result;
-    });
-
-    test('returns promise resolved with the first arg', function() {
-        assert.strictEqual(valueToResolveWith, returned);
-    });
-
-})();
-
-(function() {
-	console.log('execute with 2 args given first one is falsy');
-
-    var returned;
-    var errorToRejectWith = {};
-
-    var newPromise = require('../newThen')();
-    var p = newPromise(null, errorToRejectWith);
-
-    p.then(null, function(result) {
-        returned = result;
-    });
-
-    test('returns promise rejected with the first arg', function() {
-        assert.strictEqual(errorToRejectWith, returned);
-    });
-
-})();
+var assert = require('assert');
+var test = require('../test');
+var mock = require('../partialMock/simple/newMock');
+
+(function() {
+	console.log('execute with no args');
+
+    var isResolved;
+
+    var newPromise = require('../newThen')();
+    var p = newPromise();
+
+    p.then(function() {
+        isResolved = true;
+    });
+
+    test('returns resolved promise', function() {
+        assert.ok(isResolved);
+    });
+
+})();
+
+
+(function() {
+	console.log('execute with 1 arg');
+
+    var returned;
+    var valueToResolveWith = {};
+
+    var newPromise = require('../newThen')();
+    var p = newPromise(valueToResolveWith);
+
+    p.then(function(result) {
+        returned = result;
+    });
+
+    test('returns promise resolved with the given arg', function() {
+        assert.strictEqual(valueToResolveWith, returned);
+    });
+
+})();
+
+(function() {
+	console.log('execute with 2 args');
+
+    var returned;
+    var valueToResolveWith = {};
+    var errorToRejectWith = {};
+
+    var newPromise = require('../newThen')();
+    var p = newPromise(valueToResolveWith, errorToRejectWith);
+
+    p.then(function(result) {
+        returned = result;
+    });
+
+    test('returns promise resolved with the first arg', function() {
+        assert.strictEqual(valueToResolveWith, returned);
+    });
+
+})();
+
+(function() {
+	console.log('execute with 2 args given first one is falsy');
+
+    var returned;
+    var errorToRejectWith = {};
+
+    var newPromise = require('../newThen')();
+    var p = newPromise(null, errorToRejectWith);
+
+    p.then(null, function(result) {
+        returned = result;
+    });
+
+    test('returns promise rejected with the first arg', function() {
+        assert.strictEqual(errorToRejectWith, returned);
+    });
+
+})();

package/newThenSpec/testNoCallback.js

@@ -1,57 +1,57 @@
-var assert = require('assert');
-var test = require('../test');
-var mock = require('../partialMock/simple/newMock');
-
-(function() {
-	console.log('resove value can be carried through a long chain');
-
-	var expected = {};
-	var actual;
-
-	var p = require('../newThen')();
-	p.then(null, null)
-		.then({})
-		.then()
-		.then(function(returned) {
-			actual = returned;
-		}, mock());
-
-	p.resolve(expected);
-
-	test('invokes success', function() {
-		assert.equal(actual, expected);
-	});
-
-})();
-
-
-
-(function() {
-	console.log('reject value can be carried through a long chain');
-
-	var expected = {};
-	var actual;
-	var actual2;
-
-	var p = require('../newThen')();
-	p.then(null, null)
-		.then({})
-		.then()
-		.then(mock(), function(returned) {
-			actual = returned;
-		})
-		.then(null, function(returned) {
-			actual2 = returned;
-		} );
-
-	p.reject(expected);
-
-	test('invokes first reject', function() {
-		assert.equal(actual, expected);
-	});
-
-	test('does not invoke next rejects', function() {
-		assert.equal(actual2, undefined);
-	});
-
-})();
+var assert = require('assert');
+var test = require('../test');
+var mock = require('../partialMock/simple/newMock');
+
+(function() {
+	console.log('resove value can be carried through a long chain');
+
+	var expected = {};
+	var actual;
+
+	var p = require('../newThen')();
+	p.then(null, null)
+		.then({})
+		.then()
+		.then(function(returned) {
+			actual = returned;
+		}, mock());
+
+	p.resolve(expected);
+
+	test('invokes success', function() {
+		assert.equal(actual, expected);
+	});
+
+})();
+
+
+
+(function() {
+	console.log('reject value can be carried through a long chain');
+
+	var expected = {};
+	var actual;
+	var actual2;
+
+	var p = require('../newThen')();
+	p.then(null, null)
+		.then({})
+		.then()
+		.then(mock(), function(returned) {
+			actual = returned;
+		})
+		.then(null, function(returned) {
+			actual2 = returned;
+		} );
+
+	p.reject(expected);
+
+	test('invokes first reject', function() {
+		assert.equal(actual, expected);
+	});
+
+	test('does not invoke next rejects', function() {
+		assert.equal(actual2, undefined);
+	});
+
+})();

package/newThenSpec/testPreReject.js

@@ -1,51 +1,51 @@
-var assert = require('assert');
-var test = require('../test');
-var mock = require('../partialMock/simple/newMock');
-
-(function() {
-    console.log('then pre reject');
-
-    var expected = {};
-    var expected2 = {};
-    var actual;
-    var actual2;
-    var expectedRepeated = {};
-    var actualRepeated2;
-
-    var p = require('../newThen').reject(expected);
-    p.then(mock(),
-        function(returned) {
-            actual = returned;
-            return expected2;
-        })
-        .then(function(returned) {
-            actual2 = returned;
-        }, mock());
-
-    p.then(mock(),
-        function(returned) {
-            actualRepeated = returned;
-            return expectedRepeated;
-        })
-        .then(function(returned) {
-            actualRepeated2 = returned;
-        }, mock());
-
-
-    test('invokes failed', function() {
-        assert.equal(actual, expected);
-    });
-
-    test('invokes success when chained', function() {
-        assert.equal(actual2, expected2);
-    });
-
-    test('invokes failed when repeated', function() {
-        assert.equal(actualRepeated, expected);
-    });
-
-    test('invokes success when repeated and chained', function() {
-        assert.equal(actualRepeated2, expectedRepeated);
-    });
-    
-})();
+var assert = require('assert');
+var test = require('../test');
+var mock = require('../partialMock/simple/newMock');
+
+(function() {
+    console.log('then pre reject');
+
+    var expected = {};
+    var expected2 = {};
+    var actual;
+    var actual2;
+    var expectedRepeated = {};
+    var actualRepeated2;
+
+    var p = require('../newThen').reject(expected);
+    p.then(mock(),
+        function(returned) {
+            actual = returned;
+            return expected2;
+        })
+        .then(function(returned) {
+            actual2 = returned;
+        }, mock());
+
+    p.then(mock(),
+        function(returned) {
+            actualRepeated = returned;
+            return expectedRepeated;
+        })
+        .then(function(returned) {
+            actualRepeated2 = returned;
+        }, mock());
+
+
+    test('invokes failed', function() {
+        assert.equal(actual, expected);
+    });
+
+    test('invokes success when chained', function() {
+        assert.equal(actual2, expected2);
+    });
+
+    test('invokes failed when repeated', function() {
+        assert.equal(actualRepeated, expected);
+    });
+
+    test('invokes success when repeated and chained', function() {
+        assert.equal(actualRepeated2, expectedRepeated);
+    });
+    
+})();

package/newThenSpec/testPreRejectAndThrow.js

@@ -1,50 +1,50 @@
-var assert = require('assert');
-var test = require('../test');
-var mock = require('../partialMock/simple/newMock');
-
-(function() {
-    console.log('then throws for preRejected');
-
-    var expected = {};
-    var expected2 = {};
-    var actual;
-    var actual2;
-    var expectedRepeated = {};
-    var actualRepeated2;
-
-    var p = require('../newThen').reject(expected);
-    p.then(mock(),
-            function(returned) {
-                actual = returned;
-                throw expected2;
-            })
-        .then(null, function(returned) {
-            actual2 = returned;
-        });
-
-    p.then(mock(),
-            function(returned) {
-                actualRepeated = returned;
-                throw expectedRepeated;
-            })
-        .then(null, function(returned) {
-            actualRepeated2 = returned;
-        });
-
-    test('invokes failed', function() {
-        assert.equal(actual, expected);
-    });
-
-    test('catches following then', function() {
-        assert.equal(actual2, expected2);
-    });
-
-    test('invokes failed when repeated', function() {
-        assert.equal(actualRepeated, expected);
-    });
-
-    test('catches following then when repeated', function() {
-        assert.equal(actualRepeated2, expectedRepeated);
-    });
-
-})();
+var assert = require('assert');
+var test = require('../test');
+var mock = require('../partialMock/simple/newMock');
+
+(function() {
+    console.log('then throws for preRejected');
+
+    var expected = {};
+    var expected2 = {};
+    var actual;
+    var actual2;
+    var expectedRepeated = {};
+    var actualRepeated2;
+
+    var p = require('../newThen').reject(expected);
+    p.then(mock(),
+            function(returned) {
+                actual = returned;
+                throw expected2;
+            })
+        .then(null, function(returned) {
+            actual2 = returned;
+        });
+
+    p.then(mock(),
+            function(returned) {
+                actualRepeated = returned;
+                throw expectedRepeated;
+            })
+        .then(null, function(returned) {
+            actualRepeated2 = returned;
+        });
+
+    test('invokes failed', function() {
+        assert.equal(actual, expected);
+    });
+
+    test('catches following then', function() {
+        assert.equal(actual2, expected2);
+    });
+
+    test('invokes failed when repeated', function() {
+        assert.equal(actualRepeated, expected);
+    });
+
+    test('catches following then when repeated', function() {
+        assert.equal(actualRepeated2, expectedRepeated);
+    });
+
+})();

package/newThenSpec/testPreResolve.js

@@ -1,49 +1,49 @@
-var assert = require('assert');
-var test = require('../test');
-var mock = require('../partialMock/simple/newMock');
-
-(function() {
-    console.log('then pre resolve');
-
-    var expected = {};
-    var expected2 = {};
-    var actual;
-    var actual2;
-    var expectedRepeated = {};
-    var actualRepeated;
-    var actualRepeated2;
-
-    var p = require('../newThen').resolve(expected);
-    p.then(function(returned) {
-            actual = returned
-            return expected2;
-        }, mock())
-        .then(function(returned) {
-            actual2 = returned;
-        }, mock());
-
-    p.then(function(returned) {
-            actualRepeated = returned;
-            return expectedRepeated;
-        }, mock())
-        .then(function(returned) {
-            actualRepeated2 = returned;
-        }, mock());
-
-    test('invokes success', function() {
-        assert.equal(actual, expected);
-    });
-
-    test('invokes success when chained', function() {
-        assert.equal(actual2, expected2);
-    });
-
-    test('invokes success when called again', function() {
-        assert.equal(actualRepeated, expected);
-    });
-
-    test('invokes success when called again and chained', function() {
-        assert.equal(actualRepeated2, expectedRepeated);
-    });
-    
-})();
+var assert = require('assert');
+var test = require('../test');
+var mock = require('../partialMock/simple/newMock');
+
+(function() {
+    console.log('then pre resolve');
+
+    var expected = {};
+    var expected2 = {};
+    var actual;
+    var actual2;
+    var expectedRepeated = {};
+    var actualRepeated;
+    var actualRepeated2;
+
+    var p = require('../newThen').resolve(expected);
+    p.then(function(returned) {
+            actual = returned
+            return expected2;
+        }, mock())
+        .then(function(returned) {
+            actual2 = returned;
+        }, mock());
+
+    p.then(function(returned) {
+            actualRepeated = returned;
+            return expectedRepeated;
+        }, mock())
+        .then(function(returned) {
+            actualRepeated2 = returned;
+        }, mock());
+
+    test('invokes success', function() {
+        assert.equal(actual, expected);
+    });
+
+    test('invokes success when chained', function() {
+        assert.equal(actual2, expected2);
+    });
+
+    test('invokes success when called again', function() {
+        assert.equal(actualRepeated, expected);
+    });
+
+    test('invokes success when called again and chained', function() {
+        assert.equal(actualRepeated2, expectedRepeated);
+    });
+    
+})();

package/newThenSpec/testPreResolveAndThrow.js

@@ -1,48 +1,48 @@
-var assert = require('assert');
-var test = require('../test');
-var mock = require('../partialMock/simple/newMock');
-
-(function() {
-    console.log('then throws for preResolved');
-
-    var expected = {};
-    var expected2 = {};
-    var actual;
-    var actual2;
-    var expectedRepeated = {};
-    var actualRepeated2;
-
-    var p = require('../newThen').resolve(expected);
-    p.then(function(returned) {
-                actual = returned;
-                throw expected2;
-            }, mock())
-        .then(null, function(returned) {
-            actual2 = returned;
-        });
-
-    p.then(function(returned) {
-                actualRepeated = returned;
-                throw expectedRepeated;
-            },mock())
-        .then(null, function(returned) {
-            actualRepeated2 = returned;
-        });
-
-    test('invokes failed', function() {
-        assert.equal(actual, expected);
-    });
-
-    test('catches following then', function() {
-        assert.equal(actual2, expected2);
-    });
-
-    test('invokes failed when repeated', function() {
-        assert.equal(actualRepeated, expected);
-    });
-
-    test('catches following then when repeated', function() {
-        assert.equal(actualRepeated2, expectedRepeated);
-    });
-
-})();
+var assert = require('assert');
+var test = require('../test');
+var mock = require('../partialMock/simple/newMock');
+
+(function() {
+    console.log('then throws for preResolved');
+
+    var expected = {};
+    var expected2 = {};
+    var actual;
+    var actual2;
+    var expectedRepeated = {};
+    var actualRepeated2;
+
+    var p = require('../newThen').resolve(expected);
+    p.then(function(returned) {
+                actual = returned;
+                throw expected2;
+            }, mock())
+        .then(null, function(returned) {
+            actual2 = returned;
+        });
+
+    p.then(function(returned) {
+                actualRepeated = returned;
+                throw expectedRepeated;
+            },mock())
+        .then(null, function(returned) {
+            actualRepeated2 = returned;
+        });
+
+    test('invokes failed', function() {
+        assert.equal(actual, expected);
+    });
+
+    test('catches following then', function() {
+        assert.equal(actual2, expected2);
+    });
+
+    test('invokes failed when repeated', function() {
+        assert.equal(actualRepeated, expected);
+    });
+
+    test('catches following then when repeated', function() {
+        assert.equal(actualRepeated2, expectedRepeated);
+    });
+
+})();