Tests: toBeAborted expect extension [refactor]

overlookmotel · Mar 30, 2019 · b5a3c65 · b5a3c65
1 parent e2055ee
commit b5a3c65
Show file tree

Hide file tree

Showing 3 changed files with 127 additions and 18 deletions.
diff --git a/test/lazy.test.js b/test/lazy.test.js
@@ -7,8 +7,7 @@
 
 // Modules
 const React = require('react'),
-	{Suspense} = React,
-	{ABORT} = require('../symbols');
+	{Suspense} = React;
 
 // Imports
 const {itRenders, lazy, removeSpacing, preventUnhandledRejection} = require('./utils');
@@ -1300,7 +1299,7 @@ describe('lazy component', () => {
 			const p = render(e);
 			preventUnhandledRejection(p);
 
-			expect(Lazy.promise[ABORT]).toHaveBeenCalledTimes(1);
+			expect(Lazy).toBeAborted();
 
 			await expect(p).rejects.toThrow(NO_SUSPENSE_ERROR);
 		});
@@ -1336,7 +1335,7 @@ describe('lazy component', () => {
 			const p = render(e);
 			preventUnhandledRejection(p);
 
-			expect(Lazy.promise[ABORT]).toHaveBeenCalledTimes(1);
+			expect(Lazy).toBeAborted();
 
 			await expect(p).rejects.toThrow(NO_SUSPENSE_ERROR);
 		});
@@ -1580,14 +1579,14 @@ describe('multiple lazy components', () => {
 				const p = render(e);
 				preventUnhandledRejection(p);
 
-				expect(Lazy1.promise[ABORT]).toHaveBeenCalledTimes(1);
-				expect(Lazy2.promise[ABORT]).toHaveBeenCalledTimes(1);
+				expect(Lazy1).toBeAborted();
+				expect(Lazy2).toBeAborted();
 				if (fallbackFast) {
 					expect(Lazy3).not.toHaveBeenCalled();
 				} else {
-					expect(Lazy3.promise[ABORT]).toHaveBeenCalledTimes(1);
+					expect(Lazy3).toBeAborted();
 				}
-				expect(Lazy4.promise[ABORT]).not.toHaveBeenCalled();
+				expect(Lazy4).not.toBeAborted();
 
 				const h = await p;
 				expect(h).toBe(`<div${openTag}><span>Fallback</span><div>Lazy inner 4</div></div>`);
@@ -1806,10 +1805,10 @@ describe('nested lazy components', () => {
 
 				await Lazy3.promise;
 
-				expect(Lazy1.promise[ABORT]).toHaveBeenCalledTimes(1);
-				expect(Lazy2.promise[ABORT]).toHaveBeenCalledTimes(1);
-				expect(Lazy3.promise[ABORT]).not.toHaveBeenCalled();
-				expect(Lazy3Inner.promise[ABORT]).toHaveBeenCalledTimes(1);
+				expect(Lazy1).toBeAborted();
+				expect(Lazy2).toBeAborted();
+				expect(Lazy3).not.toBeAborted();
+				expect(Lazy3Inner).toBeAborted();
 
 				const h = await p;
 
@@ -1837,10 +1836,10 @@ describe('nested lazy components', () => {
 				await Lazy1.promise;
 				await Lazy2.promise;
 
-				expect(Lazy1.promise[ABORT]).not.toHaveBeenCalled();
-				expect(Lazy1Inner.promise[ABORT]).toHaveBeenCalledTimes(1);
-				expect(Lazy2.promise[ABORT]).not.toHaveBeenCalled();
-				expect(Lazy2Inner.promise[ABORT]).toHaveBeenCalledTimes(1);
+				expect(Lazy1).not.toBeAborted();
+				expect(Lazy1Inner).toBeAborted();
+				expect(Lazy2).not.toBeAborted();
+				expect(Lazy2Inner).toBeAborted();
 
 				const h = await p;
 

diff --git a/test/utils/expectExtensions.js b/test/utils/expectExtensions.js
@@ -6,7 +6,7 @@
 'use strict';
 
 // Modules
-const {ON_MOUNT} = require('../../symbols');
+const {ABORT, ON_MOUNT} = require('../../symbols');
 
 // Imports
 const {TEST_LAZY} = require('./symbols');
@@ -18,6 +18,26 @@ const {TEST_LAZY} = require('./symbols');
  */
 const extensions = {};
 
+extensions.toBeAborted = extensions.toAbort = function(Component) {
+	const message = `Expected ${componentName(Component)} ${this.isNot ? 'not ' : ''}to be aborted`;
+
+	// Check `[ABORT]` called correctly if was called
+	const {fail, mock, notCalled} = calledCorrectly(Component, ABORT);
+
+	// Make `expect(C).not.toBeAborted()` not error if `C` never called
+	if (notCalled && this.isNot) return failed(message);
+
+	if (fail) return passedFailed(this, message, fail);
+
+	// Check `[ABORT]` called no more than once
+	const {calls} = mock;
+	if (calls.length > 1) return passedFailed(this, message, `it was aborted ${calls.length} times`);
+
+	// Check aborted
+	if (mock.calls.length === 0) return failed(message);
+	return passed(message);
+};
+
 extensions.toBeMounted = extensions.toMount = function(Component) {
 	const message = mountBaseMessage(this, Component);
 

diff --git a/test/utils/expectExtensions.test.js b/test/utils/expectExtensions.test.js
@@ -7,14 +7,104 @@
 
 // Modules
 const React = require('react'),
-	{ON_MOUNT} = require('../../symbols');
+	{ABORT, ON_MOUNT} = require('../../symbols');
 
 // Imports
 const {lazy} = require('./index');
 
 // Tests
 
 describe('jest expect extensions (used in tests only)', () => {
+	describe('toBeAborted', () => {
+		it('passes if passed a correctly aborted lazy component', () => {
+			const Lazy = lazy(() => <div></div>);
+			const promise = tryCatch(Lazy);
+			promise[ABORT]();
+			expect(Lazy).toBeAborted();
+		});
+
+		it('errors if passed a non-function', () => {
+			expect(() => {
+				expect(null).toBeAborted();
+			}).toThrow(/^Expected component to be aborted - it is not a component$/);
+		});
+
+		it('errors if passed a function which is not a test lazy component', () => {
+			expect(() => {
+				expect(function() {}).toBeAborted();
+			}).toThrow(/^Expected component to be aborted - it is not a test lazy component$/);
+		});
+
+		it('errors if passed a component which was not called', () => {
+			const Lazy = lazy(() => <div></div>);
+			expect(() => {
+				expect(Lazy).toBeAborted();
+			}).toThrow(/^Expected Lazy to be aborted - it was not called$/);
+		});
+
+		it('errors if passed a component which was not aborted', () => {
+			const Lazy = lazy(() => <div></div>);
+			tryCatch(Lazy);
+			expect(() => {
+				expect(Lazy).toBeAborted();
+			}).toThrow(/^Expected Lazy to be aborted$/);
+		});
+
+		it('errors if passed a component which was aborted twice', () => {
+			const Lazy = lazy(() => <div></div>);
+			const promise = tryCatch(Lazy);
+			promise[ABORT]();
+			promise[ABORT]();
+			expect(() => {
+				expect(Lazy).toBeAborted();
+			}).toThrow(/^Expected Lazy to be aborted - it was aborted 2 times$/);
+		});
+	});
+
+	describe('not.toBeAborted', () => {
+		it('passes if passed a lazy component which was called but not aborted', () => {
+			const Lazy = lazy(() => <div></div>);
+			tryCatch(Lazy);
+			expect(Lazy).not.toBeAborted();
+		});
+
+		it('passes if passed a lazy component which was not called', () => {
+			const Lazy = lazy(() => <div></div>);
+			expect(Lazy).not.toBeAborted();
+		});
+
+		it('errors if passed a non-function', () => {
+			expect(() => {
+				expect(null).not.toBeAborted();
+			}).toThrow(/^Expected component not to be aborted - it is not a component$/);
+		});
+
+		it('errors if passed a function which is not a test lazy component', () => {
+			expect(() => {
+				expect(function() {}).not.toBeAborted();
+			}).toThrow(/^Expected component not to be aborted - it is not a test lazy component$/);
+		});
+
+		it('errors if passed a component which was aborted', () => {
+			const Lazy = lazy(() => <div></div>);
+			const promise = tryCatch(Lazy);
+			promise[ABORT]();
+			expect(() => {
+				expect(Lazy).not.toBeAborted();
+			}).toThrow(/^Expected Lazy not to be aborted$/);
+		});
+
+		it('errors if passed a component which was aborted twice', () => {
+			const Lazy = lazy(() => <div></div>);
+			const promise = tryCatch(Lazy);
+			promise[ABORT]();
+			promise[ABORT]();
+			expect(() => {
+				expect(Lazy).not.toBeAborted();
+			}).toThrow(/^Expected Lazy not to be aborted - it was aborted 2 times$/);
+		});
+	});
+
 	describe('toBeMounted', () => {
 		it('passes if passed a correctly mounted lazy component', () => {
 			const Lazy = lazy(() => <div></div>);