docs/_api-mocking/mock_options.md

@@ -75,11 +75,6 @@ multiParameters:
           - Integer
         content: |-
           Limits the number of times the route can be used. If the route has already been called `repeat` times, the call to `fetch()` will fall through to be handled by any other routes defined (which may eventually result in an error if nothing matches it)
-      - name: repeat
-        types:
-          - Integer
-        content: |-
-          Limits the number of times the route can be used. If the route has already been called `repeat` times, the call to `fetch()` will fall through to be handled by any other routes defined (which may eventually result in an error if nothing matches it)
   - parametersBlockTitle: Response options
     parameters:
       - name: delay

docs/v6-v7-upgrade-guide.md

@@ -1,4 +1,4 @@
-# Upgrading from V6 to V7
+# Upgrading from V6 to V7 or v8
 
 # Changes
 

src/lib/fetch-handler.js

@@ -47,11 +47,15 @@ const resolve = async (
 };
 
 FetchMock.fetchHandler = function(url, options, request) {
-	({ url, options, request } = requestUtils.normalizeRequest(
+	const normalizedRequest = requestUtils.normalizeRequest(
 		url,
 		options,
 		this.config.Request
-	));
+	);
+
+	({ url, options, request } = normalizedRequest);
+
+	const { signal } = normalizedRequest;
 
 	const route = this.executeRouter(url, options, request);
 
@@ -62,15 +66,15 @@ FetchMock.fetchHandler = function(url, options, request) {
 	// wrapped in this promise to make sure we respect custom Promise
 	// constructors defined by the user
 	return new this.config.Promise((res, rej) => {
-		if (options && options.signal) {
+		if (signal) {
 			const abort = () => {
 				rej(new AbortError());
 				done();
 			};
-			if (options.signal.aborted) {
+			if (signal.aborted) {
 				abort();
 			}
-			options.signal.addEventListener('abort', abort);
+			signal.addEventListener('abort', abort);
 		}
 
 		this.generateResponse(route, url, options, request)

src/lib/request-utils.js

@@ -39,31 +39,31 @@ module.exports = {
 	},
 	normalizeRequest: (url, options, Request) => {
 		if (Request.prototype.isPrototypeOf(url)) {
-			const obj = {
+			const derivedOptions = {
+				method: url.method
+			};
+			const normalizedRequestObject = {
 				url: normalizeUrl(url.url),
-				options: Object.assign(
-					{
-						method: url.method
-					},
-					options
-				),
-				request: url
+				options: Object.assign(derivedOptions, options),
+				request: url,
+				signal: (options && options.signal) || url.signal
 			};
 
 			const headers = headersToArray(url.headers);
 
 			if (headers.length) {
-				obj.options.headers = zipObject(headers);
+				normalizedRequestObject.options.headers = zipObject(headers);
 			}
-			return obj;
+			return normalizedRequestObject;
 		} else if (
 			typeof url === 'string' ||
 			// horrible URL object duck-typing
 			(typeof url === 'object' && 'href' in url)
 		) {
 			return {
 				url: normalizeUrl(url),
-				options: options
+				options: options,
+				signal: options && options.signal
 			};
 		} else if (typeof url === 'object') {
 			throw new TypeError(

test/specs/abortable.test.js

@@ -30,6 +30,31 @@ module.exports = (fetchMock, AbortController) => {
 			}
 		});
 
+		it('error on signal abort for request object', async () => {
+			fm.mock('http://it.at.there/', () => {
+				return new Promise(resolve => {
+					setTimeout(() => {
+						resolve({});
+					}, 500);
+				});
+			});
+
+			const controller = new AbortController();
+			setTimeout(() => controller.abort(), 300);
+
+			try {
+				await fm.fetchHandler(
+					new fm.config.Request('http://it.at.there/', {
+						signal: controller.signal
+					})
+				);
+			} catch (error) {
+				console.error(error);
+				expect(error.name).to.equal('AbortError');
+				expect(error.message).to.equal('The operation was aborted.');
+			}
+		});
+
 		it('error when signal already aborted', async () => {
 			const controller = new AbortController();
 			controller.abort();

test/specs/inspecting.test.js

@@ -485,12 +485,13 @@ module.exports = fetchMock => {
 					method: 'POST'
 				});
 				fm.fetchHandler(req);
-				expect(fm.lastCall()).to.eql([
-					'http://it.at.here/',
-					{ method: 'POST' }
-				]);
+				const [url, callOptions] = fm.lastCall();
+
+				expect(url).to.equal('http://it.at.here/');
+				expect(callOptions).to.include({ method: 'POST' });
 				expect(fm.lastUrl()).to.equal('http://it.at.here/');
-				expect(fm.lastOptions()).to.eql({ method: 'POST' });
+				const options = fm.lastOptions();
+				expect(options).to.eql({ method: 'POST' });
 				expect(fm.lastCall().request).to.equal(req);
 			});
 
@@ -499,17 +500,33 @@ module.exports = fetchMock => {
 					method: 'POST'
 				});
 				fm.fetchHandler(req, { arbitraryOption: true });
-				expect(fm.lastCall()).to.eql([
-					'http://it.at.here/',
-					{ method: 'POST', arbitraryOption: true }
-				]);
+				const [url, callOptions] = fm.lastCall();
+				expect(url).to.equal('http://it.at.here/');
+				expect(callOptions).to.include({
+					method: 'POST',
+					arbitraryOption: true
+				});
 				expect(fm.lastUrl()).to.equal('http://it.at.here/');
-				expect(fm.lastOptions()).to.eql({
+				const options = fm.lastOptions();
+
+				expect(options).to.eql({
 					method: 'POST',
 					arbitraryOption: true
 				});
 				expect(fm.lastCall().request).to.equal(req);
 			});
+
+			it('Not make default signal available in options when called with Request instance using signal', () => {
+				const req = new fm.config.Request('http://it.at.here/', {
+					method: 'POST'
+				});
+				fm.fetchHandler(req);
+				const [, callOptions] = fm.lastCall();
+
+				expect(callOptions.signal).to.be.undefined;
+				const options = fm.lastOptions();
+				expect(options.signal).to.be.undefined;
+			});
 		});
 
 		describe('flushing pending calls', () => {