npm ignore nyc_output

.eslintignore

@@ -1 +1 @@
-test
+test

.npmignore

@@ -1,8 +1,4 @@
 .eslintrc.js
 test
 .cache
-.nyc_output
-.github
-.eslintignore
-.vscode
-coverage
+.nyc_output

README.md

@@ -28,27 +28,21 @@ This module aims to expose the same API as `node-fetch` does for the most common
 
 Load the module.
 
-### await fetch(resource [, init])
+### async fetch(resource [, init])
 
 Same arguments as [node-fetch](https://www.npmjs.com/package/node-fetch).
 
 Returns a **CachedResponse**.
 
-### await CachedResponse.ejectFromCache()
-
-Eject the response from the cache, so that the next request will perform a true HTTP request rather than returning a cached response.
-
-Keep in mind that this module caches **all** responses, even if they return errors. You might want to use this function in certain cases like receiving a 5xx response status, so that you can retry requests.
-
-### await CachedResponse.text()
+### async CachedResponse.text()
 
 Returns the body as a string, same as [node-fetch](https://www.npmjs.com/package/node-fetch).
 
-### await CachedResponse.json()
+### async CachedResponse.json()
 
 Returns the body as a JavaScript object, parsed from JSON, same as [node-fetch](https://www.npmjs.com/package/node-fetch).
 
-### await CachedResponse.buffer()
+### async CachedResponse.buffer()
 
 Returns the body as a Buffer, same as [node-fetch](https://www.npmjs.com/package/node-fetch).
 
@@ -72,6 +66,12 @@ Returns true if the request was redirected, false otherwise, same as [node-fetch
 
 Returns a **ResponseHeaders** object representing the headers of the response, same as [node-fetch](https://www.npmjs.com/package/node-fetch).
 
+### async CachedResponse.ejectFromCache()
+
+Eject the response from the cache, so that the next request will perform a true HTTP request rather than returning a cached response.
+
+Keep in mind that this module caches **all** responses, even if they return error status codes. You might want to use this function when `!response.ok`, so that you can retry requests.
+
 ### ResponseHeaders.entries()
 
 Returns the raw headers as an array of `[key, value]` pairs, same as [node-fetch](https://www.npmjs.com/package/node-fetch).
@@ -114,7 +114,7 @@ This is the default cache delegate. It caches responses in-process in a POJO.
 Usage:
 
 ```js
-const { fetchBuilder, MemoryCache } = require('node-fetch-cache');
+const fetchBuilder, { MemoryCache } = require('node-fetch-cache');
 const fetch = fetchBuilder.withCache(new MemoryCache(options));
 ```
 
@@ -135,7 +135,7 @@ Cache to a directory on disk. This allows the cache to survive the process exiti
 Usage:
 
 ```js
-const  { fetchBuilder, FileSystemCache } = require('node-fetch-cache');
+const fetchBuilder, { FileSystemCache } = require('node-fetch-cache');
 const fetch = fetchBuilder.withCache(new FileSystemCache(options));
 ```
 

classes/headers.js

@@ -4,21 +4,19 @@ class Headers {
   }
 
   entries() {
-    return Object.entries(this.rawHeaders)
-      .sort((e1, e2) => e1[0].localeCompare(e2[0]))
-      .map(([key, val]) => [key, val[0]]);
+    return Object.entries(this.rawHeaders);
   }
 
   keys() {
-    return this.entries().map((e) => e[0]);
+    return Object.keys(this.rawHeaders);
   }
 
   values() {
-    return this.entries().map((e) => e[1]);
+    return Object.values(this.rawHeaders);
   }
 
   get(name) {
-    return (this.rawHeaders[name.toLowerCase()] || [])[0] || null;
+    return this.rawHeaders[name.toLowerCase()] || null;
   }
 
   has(name) {

classes/response.js

@@ -27,15 +27,15 @@ class Response {
     return this.bodyBuffer;
   }
 
-  async text() {
+  text() {
     return this.consumeBody().toString();
   }
 
-  async json() {
+  json() {
     return JSON.parse(this.consumeBody().toString());
   }
 
-  async buffer() {
+  buffer() {
     return this.consumeBody();
   }
 

index.js

@@ -4,7 +4,6 @@ const { URLSearchParams } = require('url');
 const crypto = require('crypto');
 const Response = require('./classes/response.js');
 const MemoryCache = require('./classes/caching/memory_cache.js');
-const FileSystemCache = require('./classes/caching/file_system_cache.js');
 
 const CACHE_VERSION = 2;
 
@@ -17,21 +16,27 @@ function md5(str) {
 // the cache key.
 function getFormDataCacheKey(formData) {
   const cacheKey = { ...formData };
-  const boundary = formData.getBoundary();
 
-  // eslint-disable-next-line no-underscore-dangle
-  delete cacheKey._boundary;
+  if (typeof formData.getBoundary === 'function') {
+    const boundary = formData.getBoundary();
 
-  const boundaryReplaceRegex = new RegExp(boundary, 'g');
+    // eslint-disable-next-line no-underscore-dangle
+    delete cacheKey._boundary;
 
-  // eslint-disable-next-line no-underscore-dangle
-  cacheKey._streams = cacheKey._streams.map((s) => {
-    if (typeof s === 'string') {
-      return s.replace(boundaryReplaceRegex, '');
+    // eslint-disable-next-line no-underscore-dangle
+    if (Array.isArray(cacheKey._streams)) {
+      const boundaryReplaceRegex = new RegExp(boundary, 'g');
+
+      // eslint-disable-next-line no-underscore-dangle
+      cacheKey._streams = cacheKey._streams.map((s) => {
+        if (typeof s === 'string') {
+          return s.replace(boundaryReplaceRegex, '');
+        }
+
+        return s;
+      });
     }
-
-    return s;
-  });
+  }
 
   return cacheKey;
 }
@@ -49,18 +54,14 @@ function getBodyCacheKeyJson(body) {
     return getFormDataCacheKey(body);
   }
 
-  throw new Error('Unsupported body type. Supported body types are: string, number, undefined, null, url.URLSearchParams, fs.ReadStream, FormData');
+  throw new Error('Unsupported body type');
 }
 
 function getCacheKey(requestArguments) {
   const resource = requestArguments[0];
   const init = requestArguments[1] || {};
 
-  if (typeof resource !== 'string') {
-    throw new Error('The first argument must be a string (fetch.Request is not supported).');
-  }
-
-  const resourceCacheKeyJson = { url: resource };
+  const resourceCacheKeyJson = typeof resource === 'string' ? { url: resource } : { ...resource };
   const initCacheKeyJson = { ...init };
 
   resourceCacheKeyJson.body = getBodyCacheKeyJson(resourceCacheKeyJson.body);
@@ -72,13 +73,16 @@ function getCacheKey(requestArguments) {
 async function createRawResponse(fetchRes) {
   const buffer = await fetchRes.buffer();
 
+  const rawHeaders = Array.from(fetchRes.headers.entries())
+    .reduce((aggregate, entry) => ({ ...aggregate, [entry[0]]: entry[1] }), {});
+
   return {
     status: fetchRes.status,
     statusText: fetchRes.statusText,
     type: fetchRes.type,
     url: fetchRes.url,
     ok: fetchRes.ok,
-    headers: fetchRes.headers.raw(),
+    headers: rawHeaders,
     redirected: fetchRes.redirected,
     bodyBuffer: buffer,
   };
@@ -107,9 +111,4 @@ function createFetchWithCache(cache) {
   return fetchCache;
 }
 
-const defaultFetch = createFetchWithCache(new MemoryCache());
-
-module.exports = defaultFetch;
-module.exports.fetchBuilder = defaultFetch;
-module.exports.MemoryCache = MemoryCache;
-module.exports.FileSystemCache = FileSystemCache;
+module.exports = createFetchWithCache(new MemoryCache());

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "node-fetch-cache",
-  "version": "2.0.0",
+  "version": "1.0.6",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,11 +1,11 @@
 {
   "name": "node-fetch-cache",
-  "version": "2.0.0",
+  "version": "1.0.6",
   "description": "node-fetch with a persistent cache.",
   "main": "index.js",
   "scripts": {
     "test": "mocha --timeout 10000 --exit",
-    "coverage": "nyc --reporter=lcov --reporter=text npm test",
+    "coverage": "nyc --reporter=lcov npm test",
     "lint": "./node_modules/.bin/eslint .",
     "lintfix": "./node_modules/.bin/eslint . --fix"
   },

test/tests.js

@@ -3,9 +3,9 @@ const FormData = require('form-data');
 const assert = require('assert');
 const rimraf = require('rimraf');
 const path = require('path');
-const { URLSearchParams } = require('url');
-const standardFetch = require('node-fetch');
 const FetchCache = require('../index.js');
+const { URLSearchParams } = require('url');
+const MemoryCache = require('../classes/caching/memory_cache.js');
 
 const CACHE_PATH = path.join(__dirname, '..', '.cache');
 const expectedPngBuffer = fs.readFileSync(path.join(__dirname, 'expected_png.png'));
@@ -19,200 +19,98 @@ const PNG_BODY_URL = 'https://httpbin.org/image/png';
 
 const TEXT_BODY_EXPECTED = 'User-agent: *\nDisallow: /deny\n';
 
-let cachedFetch;
+let fetch;
+let res;
 let body;
 
 function post(body) {
   return { method: 'POST', body };
 }
 
-function removeDates(arrOrObj) {
-  if (arrOrObj.date) {
-    const copy = { ...arrOrObj };
-    delete copy.date;
-    return copy;
-  }
-
-  if (Array.isArray(arrOrObj)) {
-    if (Array.isArray(arrOrObj[0])) {
-      return arrOrObj.filter(e => e[0] !== 'date');
-    }
-
-    return arrOrObj.filter(e => !Date.parse(e));
-  }
-
-  return arrOrObj;
-}
-
-function wait(ms) {
-  return new Promise((fulfill) => setTimeout(fulfill, ms));
-}
-
-async function dualFetch(...args) {
-  const [cachedFetchResponse, standardFetchResponse] = await Promise.all([
-    cachedFetch(...args),
-    standardFetch(...args),
-  ]);
-
-  return { cachedFetchResponse, standardFetchResponse };
-}
-
 beforeEach(async function() {
   rimraf.sync(CACHE_PATH);
-  cachedFetch = FetchCache.withCache(new FetchCache.MemoryCache());
+  fetch = FetchCache.withCache(new MemoryCache());
 });
 
 describe('Basic property tests', function() {
   it('Has a status property', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(cachedFetchResponse.status, standardFetchResponse.status);
+    res = await fetch(TWO_HUNDRED_URL);
+    assert.strictEqual(res.status, 200);
 
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(cachedFetchResponse.status, standardFetchResponse.status);
+    res = await fetch(TWO_HUNDRED_URL);
+    assert.strictEqual(res.status, 200);
   });
 
   it('Has a statusText property', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(cachedFetchResponse.statusText, standardFetchResponse.statusText);
+    res = await fetch(TWO_HUNDRED_URL);
+    assert.strictEqual(res.statusText, 'OK');
 
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(cachedFetchResponse.statusText, standardFetchResponse.statusText);
+    res = await fetch(TWO_HUNDRED_URL);
+    assert.strictEqual(res.statusText, 'OK');
   });
 
   it('Has a url property', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(cachedFetchResponse.url, standardFetchResponse.url);
+    res = await fetch(TWO_HUNDRED_URL);
+    assert.strictEqual(res.url, TWO_HUNDRED_URL);
 
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(cachedFetchResponse.url, standardFetchResponse.url);
+    res = await fetch(TWO_HUNDRED_URL);
+    assert.strictEqual(res.url, TWO_HUNDRED_URL);
   });
 
   it('Has an ok property', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(FOUR_HUNDRED_URL);
-    assert.strictEqual(cachedFetchResponse.ok, standardFetchResponse.ok);
-    assert.strictEqual(cachedFetchResponse.status, standardFetchResponse.status);
+    res = await fetch(FOUR_HUNDRED_URL);
+    assert.strictEqual(res.ok, false);
+    assert.strictEqual(res.status, 400);
 
-    cachedFetchResponse = await cachedFetch(FOUR_HUNDRED_URL);
-    assert.strictEqual(cachedFetchResponse.ok, standardFetchResponse.ok);
-    assert.strictEqual(cachedFetchResponse.status, standardFetchResponse.status);
+    res = await fetch(FOUR_HUNDRED_URL);
+    assert.strictEqual(res.ok, false);
+    assert.strictEqual(res.status, 400);
+  });
+
+  it('Has a headers property', async function() {
+    res = await fetch(TWO_HUNDRED_URL);
+    assert.notStrictEqual(res.headers, undefined);
+
+    res = await fetch(TWO_HUNDRED_URL);
+    assert.notStrictEqual(res.headers, undefined);
   });
 
   it('Has a redirected property', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(THREE_HUNDRED_TWO_URL);
-    assert.strictEqual(cachedFetchResponse.redirected, standardFetchResponse.redirected);
+    res = await fetch(THREE_HUNDRED_TWO_URL);
+    assert.strictEqual(res.redirected, true);
 
-    cachedFetchResponse = await cachedFetch(THREE_HUNDRED_TWO_URL);
-    assert.strictEqual(cachedFetchResponse.redirected, standardFetchResponse.redirected);
-  });
-}).timeout(10000);
-
-describe('Header tests', function() {
-  it('Gets correct raw headers', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(
-      removeDates(cachedFetchResponse.headers.raw()),
-      removeDates(standardFetchResponse.headers.raw()),
-    );
-
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(
-      removeDates(cachedFetchResponse.headers.raw()),
-      removeDates(standardFetchResponse.headers.raw()),
-    );
-  });
-
-  it('Gets correct header keys', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(cachedFetchResponse.headers.keys(), [...standardFetchResponse.headers.keys()]);
-
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(cachedFetchResponse.headers.keys(), [...standardFetchResponse.headers.keys()]);
-  });
-
-  it('Gets correct header values', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(
-      removeDates(cachedFetchResponse.headers.values()),
-      removeDates([...standardFetchResponse.headers.values()]),
-    );
-
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(
-      removeDates(cachedFetchResponse.headers.values()),
-      removeDates([...standardFetchResponse.headers.values()]),
-    );
-  });
-
-  it('Gets correct header entries', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(
-      removeDates(cachedFetchResponse.headers.entries()),
-      removeDates([...standardFetchResponse.headers.entries()]),
-    );
-
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(
-      removeDates(cachedFetchResponse.headers.entries()),
-      removeDates([...standardFetchResponse.headers.entries()]),
-    );
-  });
-
-  it('Can get a header by value', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert(standardFetchResponse.headers.get('content-length'));
-    assert.deepStrictEqual(cachedFetchResponse.headers.get('content-length'), standardFetchResponse.headers.get('content-length'));
-
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(cachedFetchResponse.headers.get('content-length'), standardFetchResponse.headers.get('content-length'));
-  });
-
-  it('Returns undefined for non-existent header', async function() {
-    const headerName = 'zzzz';
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert(!standardFetchResponse.headers.get(headerName));
-    assert.deepStrictEqual(cachedFetchResponse.headers.get(headerName), standardFetchResponse.headers.get(headerName));
-
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(cachedFetchResponse.headers.get(headerName), standardFetchResponse.headers.get(headerName));
-  });
-
-  it('Can get whether a header is present', async function() {
-    let { cachedFetchResponse, standardFetchResponse } = await dualFetch(TWO_HUNDRED_URL);
-    assert(standardFetchResponse.headers.has('content-length'));
-    assert.deepStrictEqual(cachedFetchResponse.headers.has('content-length'), standardFetchResponse.headers.has('content-length'));
-
-    cachedFetchResponse = await cachedFetch(TWO_HUNDRED_URL);
-    assert.deepStrictEqual(cachedFetchResponse.headers.has('content-length'), standardFetchResponse.headers.has('content-length'));
+    res = await fetch(THREE_HUNDRED_TWO_URL);
+    assert.strictEqual(res.redirected, true);
   });
 }).timeout(10000);
 
 describe('Cache tests', function() {
   it('Uses cache', async function() {
-    res = await cachedFetch(TWO_HUNDRED_URL);
+    res = await fetch(TWO_HUNDRED_URL);
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL);
+    res = await fetch(TWO_HUNDRED_URL);
     assert.strictEqual(res.fromCache, true);
   });
 
   it('Can eject from cache', async function() {
-    res = await cachedFetch(TWO_HUNDRED_URL);
+    res = await fetch(TWO_HUNDRED_URL);
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL);
+    res = await fetch(TWO_HUNDRED_URL);
     assert.strictEqual(res.fromCache, true);
 
     await res.ejectFromCache();
 
-    res = await cachedFetch(TWO_HUNDRED_URL);
+    res = await fetch(TWO_HUNDRED_URL);
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL);
+    res = await fetch(TWO_HUNDRED_URL);
     assert.strictEqual(res.fromCache, true);
   });
 
-  it('Does not error if ejecting from cache twice', async function() {
-    res = await cachedFetch(TWO_HUNDRED_URL);
+  it('Does not error if rejecting from cache twice', async function() {
+    res = await fetch(TWO_HUNDRED_URL);
     assert.strictEqual(res.fromCache, false);
 
     await res.ejectFromCache();
@@ -220,34 +118,34 @@ describe('Cache tests', function() {
   });
 
   it('Gives different string bodies different cache keys', async function() {
-    res = await cachedFetch(TWO_HUNDRED_URL, post('a'));
+    res = await fetch(TWO_HUNDRED_URL, post('a'));
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post('b'));
+    res = await fetch(TWO_HUNDRED_URL, post('b'));
     assert.strictEqual(res.fromCache, false);
   });
 
   it('Gives same string bodies same cache keys', async function() {
-    res = await cachedFetch(TWO_HUNDRED_URL, post('a'));
+    res = await fetch(TWO_HUNDRED_URL, post('a'));
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post('a'));
+    res = await fetch(TWO_HUNDRED_URL, post('a'));
     assert.strictEqual(res.fromCache, true);
   });
 
   it('Gives different URLSearchParams different cache keys', async function() {
-    res = await cachedFetch(TWO_HUNDRED_URL, post(new URLSearchParams('a=a')));
+    res = await fetch(TWO_HUNDRED_URL, post(new URLSearchParams('a=a')));
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(new URLSearchParams('a=b')));
+    res = await fetch(TWO_HUNDRED_URL, post(new URLSearchParams('a=b')));
     assert.strictEqual(res.fromCache, false);
   });
 
   it('Gives same URLSearchParams same cache keys', async function() {
-    res = await cachedFetch(TWO_HUNDRED_URL, post(new URLSearchParams('a=a')));
+    res = await fetch(TWO_HUNDRED_URL, post(new URLSearchParams('a=a')));
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(new URLSearchParams('a=a')));
+    res = await fetch(TWO_HUNDRED_URL, post(new URLSearchParams('a=a')));
     assert.strictEqual(res.fromCache, true);
   });
 
@@ -255,20 +153,20 @@ describe('Cache tests', function() {
     const s1 = fs.createReadStream(__filename);
     const s2 = fs.createReadStream(path.join(__dirname, '..', 'index.js'));
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(s1));
+    res = await fetch(TWO_HUNDRED_URL, post(s1));
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(s2));
+    res = await fetch(TWO_HUNDRED_URL, post(s2));
     assert.strictEqual(res.fromCache, false);
   });
 
   it('Gives the same read streams the same cache key', async function() {
     const s1 = fs.createReadStream(__filename);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(s1));
+    res = await fetch(TWO_HUNDRED_URL, post(s1));
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(s1));
+    res = await fetch(TWO_HUNDRED_URL, post(s1));
     assert.strictEqual(res.fromCache, true);
   });
 
@@ -279,10 +177,10 @@ describe('Cache tests', function() {
     const data2 = new FormData();
     data2.append('b', 'b');
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(data1));
+    res = await fetch(TWO_HUNDRED_URL, post(data1));
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(data2));
+    res = await fetch(TWO_HUNDRED_URL, post(data2));
     assert.strictEqual(res.fromCache, false);
   });
 
@@ -293,75 +191,65 @@ describe('Cache tests', function() {
     const data2 = new FormData();
     data2.append('a', 'a');
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(data1));
+    res = await fetch(TWO_HUNDRED_URL, post(data1));
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TWO_HUNDRED_URL, post(data2));
+    res = await fetch(TWO_HUNDRED_URL, post(data2));
     assert.strictEqual(res.fromCache, true);
   });
 }).timeout(10000);
 
 describe('Data tests', function() {
-  it('Does not support Request objects', async function() {
-    try {
-      const request = new standardFetch.Request('https://google.com');
-      await cachedFetch(request);
-      throw new Error('The above line should have thrown.');
-    } catch (err) {
-      assert(err.message.includes('The first argument must be a string (fetch.Request is not supported).'));
-    }
-  });
-
   it('Refuses to consume body twice', async function() {
-    res = await cachedFetch(TEXT_BODY_URL);
+    res = await fetch(TEXT_BODY_URL);
     await res.text();
 
     try {
       await res.text();
       throw new Error('The above line should have thrown.');
     } catch (err) {
-      assert(err.message.includes('Error: body used already'));
+      // It threw
     }
   });
 
   it('Can get text body', async function() {
-    res = await cachedFetch(TEXT_BODY_URL);
+    res = await fetch(TEXT_BODY_URL);
     body = await res.text();
     assert.strictEqual(body, TEXT_BODY_EXPECTED);
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TEXT_BODY_URL);
+    res = await fetch(TEXT_BODY_URL);
     body = await res.text();
     assert.strictEqual(body, TEXT_BODY_EXPECTED);
     assert.strictEqual(res.fromCache, true);
   });
 
   it('Can get JSON body', async function() {
-    res = await cachedFetch(JSON_BODY_URL);
+    res = await fetch(JSON_BODY_URL);
     body = await res.json();
     assert(body.slideshow);
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(JSON_BODY_URL);
+    res = await fetch(JSON_BODY_URL);
     body = await res.json();
     assert(body.slideshow);
     assert.strictEqual(res.fromCache, true);
   });
 
   it('Can get PNG buffer body', async function() {
-    res = await cachedFetch(PNG_BODY_URL);
+    res = await fetch(PNG_BODY_URL);
     body = await res.buffer();
     assert.strictEqual(expectedPngBuffer.equals(body), true);
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(PNG_BODY_URL);
+    res = await fetch(PNG_BODY_URL);
     body = await res.buffer();
     assert.strictEqual(expectedPngBuffer.equals(body), true);
     assert.strictEqual(res.fromCache, true);
   });
 
   it('Can stream a body', async function() {
-    res = await cachedFetch(TEXT_BODY_URL);
+    res = await fetch(TEXT_BODY_URL);
     body = '';
 
     for await (const chunk of res.body) {
@@ -371,7 +259,7 @@ describe('Data tests', function() {
     assert.strictEqual(TEXT_BODY_EXPECTED, body);
     assert.strictEqual(res.fromCache, false);
 
-    res = await cachedFetch(TEXT_BODY_URL);
+    res = await fetch(TEXT_BODY_URL);
     body = '';
 
     for await (const chunk of res.body) {
@@ -381,56 +269,4 @@ describe('Data tests', function() {
     assert.strictEqual(TEXT_BODY_EXPECTED, body);
     assert.strictEqual(res.fromCache, true);
   });
-
-  it('Errors if the body type is not supported', async function() {
-    try {
-      await cachedFetch(TEXT_BODY_URL, { body: {} });
-      throw new Error('It was supposed to throw');
-    } catch (err) {
-      assert(err.message.includes('Unsupported body type'));
-    }
-  });
 }).timeout(10000);
-
-describe('Memory cache tests', function() {
-  it('Supports TTL', async function() {
-    cachedFetch = FetchCache.withCache(new FetchCache.MemoryCache({ ttl: 100 }));
-    let res = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(res.fromCache, false);
-    res = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(res.fromCache, true);
-
-    await wait(200);
-
-    res = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(res.fromCache, false);
-  });
-}).timeout(10000);
-
-describe('File system cache tests', function() {
-  it('Supports TTL', async function() {
-    cachedFetch = FetchCache.withCache(new FetchCache.FileSystemCache({ ttl: 100 }));
-    let res = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(res.fromCache, false);
-    res = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(res.fromCache, true);
-
-    await wait(200);
-
-    res = await cachedFetch(TWO_HUNDRED_URL);
-    assert.strictEqual(res.fromCache, false);
-  });
-
-  it('Can get PNG buffer body', async function() {
-    cachedFetch = FetchCache.withCache(new FetchCache.FileSystemCache());
-    res = await cachedFetch(PNG_BODY_URL);
-    body = await res.buffer();
-    assert.strictEqual(expectedPngBuffer.equals(body), true);
-    assert.strictEqual(res.fromCache, false);
-
-    res = await cachedFetch(PNG_BODY_URL);
-    body = await res.buffer();
-    assert.strictEqual(expectedPngBuffer.equals(body), true);
-    assert.strictEqual(res.fromCache, true);
-  });
-});