From d98bf7690119d81423b974331ebf0c18958ab8ff Mon Sep 17 00:00:00 2001
From: Muthu Kumar <muthukumar@thefeathers.in>
Date: Mon, 6 Aug 2018 09:33:31 +0530
Subject: [PATCH] [refactor]

---
 gunner/lib/expect.js | 64 ++++++++++++++++++++++++++++++----------------------
 sample.test.js       | 52 ++++++++++++++++++++++--------------------
 2 files changed, 64 insertions(+), 52 deletions(-)

diff --git a/gunner/lib/expect.js b/gunner/lib/expect.js
index ea1e8ae..fe1e5c2 100644
--- a/gunner/lib/expect.js
+++ b/gunner/lib/expect.js
@@ -1,33 +1,43 @@
 const isEq = require('@codefeathers/iseq');
 
-const { stringify } = require('../../util/helpers');
+const { stringify, liftPromise, isPromise } = require('../../util/helpers');
 const _assertPromise = require('./assertPromise');
 
-const expectPromise = (pred, statement, options = {}) => a => (...b) => {
-	if(a && typeof a.then === 'function') {
-		return (
-			a
-			.then(x =>
-				_assertPromise(
-					pred(a, ...b),
-					statement(x, ...b)
-				)
+const assertPromise = (
+	pred,
+	statement,
+	value,
+	original,
+	...testValues
+) => _assertPromise(
+	pred(original, ...testValues),
+	statement(value, ...testValues)
+);
+
+const expectPromise = (pred, statement, options = {}) =>
+	toTest =>
+		(...testValues) =>
+			liftPromise(
+				x => assertPromise(
+					pred,
+					statement,
+					x,
+					toTest,
+					...testValues
+				),
+				toTest
 			)
-			.catch(e =>
-				options.shouldNotCatch
-					? _assertPromise(
-						pred(a, ...b),
-						statement(e, ...b)
+			.catch(rejectedValue =>
+				options.shouldCatch
+					? assertPromise(
+						pred,
+						statement,
+						rejectedValue,
+						toTest,
+						...testValues
 					)
-					: Promise.reject(e)
-			)
-		);
-	}
-	return _assertPromise(
-		pred(a, ...b),
-		statement(a, ...b)
-	);
-};
+					: Promise.reject(rejectedValue)
+			);
 
 const expect = thing => {
 
@@ -54,17 +64,17 @@ const expect = thing => {
 			(a, b, c) => `Pair <${b}, ${c}> does not exist in ${stringify(a)}`,
 		)(thing),
 		resolvesTo : expectPromise(
-			(a, b) => (a && typeof a.then === 'function')
+			(a, b) => isPromise(a)
 				? a.then(x => x === b ? Promise.resolve() : Promise.reject())
 				: Promise.reject(`${a} was not a Promise`),
 			(a, b) => `${a} does not resolve to ${b}`,
 		)(thing),
 		isPromise : expectPromise(
-			a => (a && typeof a.then === 'function')
+			a => isPromise(a)
 				? a.then(() => Promise.resolve()).catch(() => Promise.resolve())
 				: Promise.reject(),
 			a => `${a} is not a Promise`,
-			{ shouldNotCatch: true },
+			{ shouldCatch: true },
 		)(thing),
 	});
 
diff --git a/sample.test.js b/sample.test.js
index 5bef2b1..2285f5c 100644
--- a/sample.test.js
+++ b/sample.test.js
@@ -5,12 +5,32 @@ const a = 1;
 gunner.test('should automatically pass', expect => expect().done());
 gunner.test(`should be equal`, expect => expect(1).equal(1));
 gunner.test(`objects are deep equal`, expect => expect({ a: 1 }).deepEqual({ a: 1 }));
-gunner.test(`objects aren't deeply equal`, expect => expect({a : 1}).deepEqual({ a: 2 }));
 gunner.test('expression should be true', expect => expect(a === 1).isTrue());
-gunner.test('promise must reject', expect =>
+
+gunner.test('should be a Promise (resolved)', expect =>
+	expect(Promise.resolve()).isPromise());
+
+gunner.test('should be a Promise (rejected)', expect =>
+	expect(Promise.reject()).isPromise());
+
+gunner.test('should resolve to 5', expect =>
+	expect(Promise.resolve(5)).resolvesTo(5));
+
+gunner.test('file must have hello as content', async expect => {
+	const { readFile } = require('fs').promises;
+	const file = await readFile('./hello.txt', { encoding: 'utf8' });
+	return [
+		expect(file).equal('hello'),
+		expect(file.length).equal(5),
+	];
+});
+
+gunner.test(`(should fail) objects aren't deeply equal`, expect => expect({a : 1}).deepEqual({ a: 2 }));
+
+gunner.test('(should fail) promise must reject', expect =>
 	expect(Promise.reject(new Error('Promise Rejected'))).equal('no rejection'));
 
-gunner.test('multiple expect', expect => {
+gunner.test('(should fail) multiple expect', expect => {
 
 	const a = { };
 	a.b = 1;
@@ -27,30 +47,12 @@ const flamethrower = () => {
 	throw new Error('This burns!');
 };
 
-gunner.test('should catch error', expect => {
+gunner.test('(should fail) should catch error', expect => {
 	return expect(flamethrower()).equal(5);
 });
 
-gunner.test('should be a Promise (resolved)', expect =>
-	expect(Promise.resolve()).isPromise());
-
-gunner.test('should be a Promise (rejected)', expect =>
-	expect(Promise.reject()).isPromise());
-
-gunner.test('should resolve to 5', expect =>
-	expect(Promise.resolve(5)).resolvesTo(5));
-
-gunner.test('should not resolve to 5', expect =>
-	expect(Promise.resolve()).resolvesTo(5));
-
-gunner.test('file must have hello as content', async expect => {
-	const { readFile } = require('fs').promises;
-	const file = await readFile('./hello.txt', { encoding: 'utf8' });
-	return [
-		expect(file).equal('hello'),
-		expect(file.length).equal(5),
-	];
-});
+gunner.test('(should fail) should not resolve to 5', expect =>
+	expect(Promise.resolve({})).resolvesTo(5));
 
 
-gunner.run({ trace: false });
+gunner.run({ trace: true});