m/metamask-extension
1
0
Fork 0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-11-25 03:20:23 +01:00
Code
d8818a47c4
metamask-extension/ui/app/helpers/utils/fetch-with-cache.test.js

121 lines
3.5 KiB
JavaScript
Raw Normal View History

Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
import assert from 'assert'
import nock from 'nock'
import sinon from 'sinon'
import proxyquire from 'proxyquire'
const fakeLocalStorageHelpers = {}
const fetchWithCache = proxyquire('./fetch-with-cache', {
'../../../lib/local-storage-helpers': fakeLocalStorageHelpers,
}).default
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
describe('Fetch with cache', function () {
beforeEach(function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
fakeLocalStorageHelpers.loadLocalStorageData = sinon.stub()
fakeLocalStorageHelpers.saveLocalStorageData = sinon.stub()
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
afterEach(function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
sinon.restore()
nock.cleanAll()
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
it('fetches a url', async function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 1}')
const response = await fetchWithCache('https://fetchwithcache.metamask.io/price')
assert.deepEqual(response, {
average: 1,
})
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
it('returns cached response', async function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 2}')
fakeLocalStorageHelpers.loadLocalStorageData.returns({
'https://fetchwithcache.metamask.io/price': {
cachedResponse: { average: 1 },
cachedTime: Date.now(),
},
})
const response = await fetchWithCache('https://fetchwithcache.metamask.io/price')
assert.deepEqual(response, {
average: 1,
})
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
it('fetches URL again after cache refresh time has passed', async function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 3}')
fakeLocalStorageHelpers.loadLocalStorageData.returns({
'https://fetchwithcache.metamask.io/cached': {
cachedResponse: { average: 1 },
cachedTime: Date.now() - 1000,
},
})
const response = await fetchWithCache('https://fetchwithcache.metamask.io/price', {}, { cacheRefreshTime: 123 })
assert.deepEqual(response, {
average: 3,
})
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
it('should abort the request when the custom timeout is hit', async function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
nock('https://fetchwithcache.metamask.io')
.get('/price')
.delay(100)
.reply(200, '{"average": 4}')
Update fetchWithCacheTests to use assert.rejects (#8334)
2020-04-14 17:33:33 +02:00
await assert.rejects(
() => fetchWithCache('https://fetchwithcache.metamask.io/price', {}, { timeout: 20 }),
{ name: 'AbortError', message: 'Aborted' },
)
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
it('throws when the response is unsuccessful', async function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(500, '{"average": 6}')
Update fetchWithCacheTests to use assert.rejects (#8334)
2020-04-14 17:33:33 +02:00
await assert.rejects(
() => fetchWithCache('https://fetchwithcache.metamask.io/price'),
)
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
it('throws when a POST request is attempted', async function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
nock('https://fetchwithcache.metamask.io')
.post('/price')
.reply(200, '{"average": 7}')
Update fetchWithCacheTests to use assert.rejects (#8334)
2020-04-14 17:33:33 +02:00
await assert.rejects(
() => fetchWithCache('https://fetchwithcache.metamask.io/price', { method: 'POST' }),
)
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
it('throws when the request has a truthy body', async function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 8}')
Update fetchWithCacheTests to use assert.rejects (#8334)
2020-04-14 17:33:33 +02:00
await assert.rejects(
() => fetchWithCache('https://fetchwithcache.metamask.io/price', { body: 1 }),
)
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
})
Update ESLint rules for test suite (#8023) * Use @metamask/eslint-config@1.1.0 * Use eslint-plugin-mocha@6.2.2 * Mark root ESLint config as root * Update Mocha ESLint rules with shared ESLint config
2020-02-11 17:51:13 +01:00
it('throws when the request has an invalid Content-Type header', async function () {
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 9}')
Update fetchWithCacheTests to use assert.rejects (#8334)
2020-04-14 17:33:33 +02:00
await assert.rejects(
() => fetchWithCache('https://fetchwithcache.metamask.io/price', { headers: { 'Content-Type': 'text/plain' } }),
{ message: 'fetchWithCache only supports JSON responses' },
)
Fix fetch-with-cache (#7083) The `fetch-with-cache` utility was failing to actually cache anything. It would cache an object with cache time and URL, and would return that instead of a valid response. This resulted in the error: `TypeError: fourByteResponse.json is not a function` The utility was updated to call `.json()` within itself, and cache the JSON response. The function signature was updated as well, to expect an options object instead of just the `cacheRefreshTime` option. The timeout was added to this options object, which helped with testing. The utility method now also handles unsuccessfull responses, and incompatible `fetch` options.
2019-09-04 21:10:23 +02:00
})
})
Copy Permalink