Async Map Sort Specs

- Fixed testing issues with async map sort spec
- Adjusted playground to be a consistent es6 format for promises
- Fixed issues in async sort specs where it wasn't assigning the right callback

Author: Sykander

docs/playground.js

@@ -8,10 +8,11 @@ const users = [1, 2, 3, 4, 5].map(() => ({
 }));
 
 // Async Sort
-await AsyncArray.asyncSort(
+const sortedUsers = await AsyncArray.asyncSort(
 	users,
-	async ({ email: emailA }, { email: emailB }) => await emailA.localeCompare(emailB)
-).then(sortedUsers => {
-	console.log('Asynchronously sorted users');
-	console.table(sortedUsers);
-});
+	async ({ email: emailA }, { email: emailB }) =>
+		await emailA.localeCompare(emailB)
+);
+
+console.log('Asynchronously sorted users');
+console.table(sortedUsers);

src/async-map-sort.js

@@ -21,9 +21,10 @@ const asyncMapSort = (module.exports.asyncMapSort = async function asyncMapSort(
 	validateIsFunction(mappingFunction);
 	validateIsFunction(comparisonFunction);
 
-	const mappedItems = await asyncMapOverIterable(this, mappingFunction);
-
-	return asyncSortIterable(mappedItems, comparisonFunction);
+	return asyncSortIterable(
+		await asyncMapOverIterable(this, mappingFunction),
+		comparisonFunction
+	);
 });
 
 /**

test/async-map-sort.spec.js

@@ -31,10 +31,6 @@ context('Async Map Sort', () => {
 			));
 	});
 
-	describe('Given no comparisonFunction', () => {
-		// It should map and then sort by unicode
-	});
-
 	describe('Given a synchronous mappingFunction', () => {
 		let result, mappingFunction, mapSortedArray;
 
@@ -47,18 +43,16 @@ context('Async Map Sort', () => {
 		it('Should run each mappingFunction in order', () =>
 			ranCallbacksInOrder(result));
 
-		it('Should map each item in order', async () => {
-			mapSortedArray.every((item, index) =>
-				expect(item).to.equal(array[index])
-			);
-		});
-
 		it('Should resolve to a new array', async () => {
 			expect(mapSortedArray).to.not.equal(array);
 		});
 
 		it('Should sort by unicode after mapping', async () => {
-			// should sort by unicode
+			const expectedResult = mapSortedArray.slice().sort();
+
+			expectedResult.every((item, index) =>
+				expect(mapSortedArray[index]).to.equal(item)
+			);
 		});
 	});
 
@@ -76,18 +70,16 @@ context('Async Map Sort', () => {
 		it('Should run each mappingFunction in order', () =>
 			ranCallbacksInOrder(result));
 
-		it('Should map each item in order', async () => {
-			mapSortedArray.every((item, index) =>
-				expect(item).to.equal(array[index])
-			);
-		});
-
 		it('Should resolve to a new array', async () => {
 			expect(mapSortedArray).to.not.equal(array);
 		});
 
 		it('Should sort by unicode after mapping', async () => {
-			// should sort by unicode
+			const expectedResult = mapSortedArray.slice().sort();
+
+			expectedResult.every((item, index) =>
+				expect(mapSortedArray[index]).to.equal(item)
+			);
 		});
 	});
 
@@ -123,26 +115,23 @@ context('Async Map Sort', () => {
 			]));
 	});
 
-	describe('Given the optional comparisonFunction parameter', () => {
-		let result, mappingFunction, mapSortedArray, comparisonFunction;
+	describe('Given an optional comparisonFunction that uses all arguments', () => {
+		let result, mappingFunction, comparisonFunction;
 
 		beforeEach(async () => {
 			({ callback: mappingFunction } = getCallback());
 			({ result, callback: comparisonFunction } = getCallback({
 				isSort: true
 			}));
 
-			mapSortedArray = await asyncMapSort(
-				array,
-				mappingFunction,
-				comparisonFunction
-			);
+			await asyncMapSort(array, mappingFunction, comparisonFunction);
 		});
 
-		it('Should sort by the given comparisonFunction after mapping', async () => {
-			expect(mapSortedArray);
-			expect(result);
-			// returned array should have correct ordering given the comparison
-		});
+		it('Should have access to first and second elements', () =>
+			result.every(({ firstEl, secondEl }) =>
+				expect(array)
+					.to.contain(firstEl)
+					.and.contain(secondEl)
+			));
 	});
 });

test/async-sort.spec.js

@@ -39,7 +39,7 @@ context('Async Sort', () => {
 		let compareFunc, sortedArray;
 
 		beforeEach(async () => {
-			({ compareFunc } = getCallback({ isSort: true }));
+			({ callback: compareFunc } = getCallback({ isSort: true }));
 
 			sortedArray = await asyncSort(array, compareFunc);
 		});
@@ -58,7 +58,7 @@ context('Async Sort', () => {
 		let compareFunc, sortedArray;
 
 		beforeEach(async () => {
-			({ compareFunc } = getCallback({ isSort: true }));
+			({ callback: compareFunc } = getCallback({ isSort: true }));
 
 			sortedArray = await asyncSort(array, compareFunc, array);
 		});
@@ -92,7 +92,7 @@ context('Async Sort', () => {
 		let compareFunc, result;
 
 		beforeEach(async () => {
-			({ result, compareFunc } = getCallback({ isSort: true }));
+			({ result, callback: compareFunc } = getCallback({ isSort: true }));
 
 			await asyncSort(array, compareFunc);
 		});