TheDude
/
ciphermask
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
A Metamask fork with Infura removed and default networks editable
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
11725 Commits
2 Branches
1 Tag
200 MiB
Tag: Branch: Tree: e82ab94699
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e82ab94699'
${ noResults }
ciphermask/ui/app/helpers/utils/fetch-with-cache.test.js

174 lines
4.5 KiB
Raw Normal View History Unescape

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.
5 years ago
import assert from 'assert'
import nock from 'nock'
import sinon from 'sinon'
import proxyquire from 'proxyquire'
Use async storage instead of localstorage (#9919)
4 years ago
const fakeStorage = {}
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.
5 years ago
const fetchWithCache = proxyquire('./fetch-with-cache', {
Use async storage instead of localstorage (#9919)
4 years ago
'../../../lib/storage-helpers': fakeStorage,
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.
5 years ago
}).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
5 years ago
describe('Fetch with cache', function () {
beforeEach(function () {
Use async storage instead of localstorage (#9919)
4 years ago
fakeStorage.getStorageItem = sinon.stub()
fakeStorage.setStorageItem = sinon.stub()
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.
5 years ago
})
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
5 years ago
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.
5 years ago
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
5 years ago
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.
5 years ago
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 1}')
[RFC] add prettier to eslint (#8595)
4 years ago
const response = await fetchWithCache(
'https://fetchwithcache.metamask.io/price',
)
Use strict equality in unit tests (#9966)
4 years ago
assert.deepStrictEqual(response, {
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.
5 years ago
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
5 years ago
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.
5 years ago
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 2}')
Use async storage instead of localstorage (#9919)
4 years ago
fakeStorage.getStorageItem.returns({
Fix `fetch-with-cache` handling of interwoven requests (#10079) A data race was introduced in #9919 when the old synchronous storage API was replaced with an async storage API. The problem arises when `fetchWithCache` is called a second time while it's still processing another call. In this case, the `cachedFetch` object can become stale while blocked waiting for a fetch response, and result in a cache being overwritten unintentionally. See this example (options omitted for simplicity, and assuming an empty initial cache): ``` await Promise.all([ fetchWithCache('https://metamask.io/foo'), fetchWithCache('https://metamask.io/bar'), ] ``` The order of events could be as follows: 1. Empty cache retrieved for `/foo` route 2. Empty cache retrieved for `/bar` route 3. Call made to `/foo` route 4. Call made to `/bar` route 5. `/foo` response is added to the empty cache object retrieved in step 1, then is saved in the cache. 6. `/bar` response is added to the empty cache object retrieved in step 2, then is saved in the cache. In step 6, the cache object saved would not contain the `/foo` response set in step 5. As a result, `/foo` would never be cached. This problem was resolved by embedding the URL being cached directly in the cache key. This prevents simultaneous responses from overwriting each others caches. Technically a data race still exists when handing simultaneous responses to the same route, but the result would be that the last call to finish would overwrite the previous. This seems acceptable.
4 years ago
cachedResponse: { average: 1 },
cachedTime: Date.now(),
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.
5 years ago
})
[RFC] add prettier to eslint (#8595)
4 years ago
const response = await fetchWithCache(
'https://fetchwithcache.metamask.io/price',
)
Use strict equality in unit tests (#9966)
4 years ago
assert.deepStrictEqual(response, {
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.
5 years ago
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
5 years ago
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.
5 years ago
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 3}')
Use async storage instead of localstorage (#9919)
4 years ago
fakeStorage.getStorageItem.returns({
Fix `fetch-with-cache` handling of interwoven requests (#10079) A data race was introduced in #9919 when the old synchronous storage API was replaced with an async storage API. The problem arises when `fetchWithCache` is called a second time while it's still processing another call. In this case, the `cachedFetch` object can become stale while blocked waiting for a fetch response, and result in a cache being overwritten unintentionally. See this example (options omitted for simplicity, and assuming an empty initial cache): ``` await Promise.all([ fetchWithCache('https://metamask.io/foo'), fetchWithCache('https://metamask.io/bar'), ] ``` The order of events could be as follows: 1. Empty cache retrieved for `/foo` route 2. Empty cache retrieved for `/bar` route 3. Call made to `/foo` route 4. Call made to `/bar` route 5. `/foo` response is added to the empty cache object retrieved in step 1, then is saved in the cache. 6. `/bar` response is added to the empty cache object retrieved in step 2, then is saved in the cache. In step 6, the cache object saved would not contain the `/foo` response set in step 5. As a result, `/foo` would never be cached. This problem was resolved by embedding the URL being cached directly in the cache key. This prevents simultaneous responses from overwriting each others caches. Technically a data race still exists when handing simultaneous responses to the same route, but the result would be that the last call to finish would overwrite the previous. This seems acceptable.
4 years ago
cachedResponse: { average: 1 },
cachedTime: Date.now() - 1000,
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.
5 years ago
})
[RFC] add prettier to eslint (#8595)
4 years ago
const response = await fetchWithCache(
'https://fetchwithcache.metamask.io/price',
{},
{ cacheRefreshTime: 123 },
)
Use strict equality in unit tests (#9966)
4 years ago
assert.deepStrictEqual(response, {
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.
5 years ago
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
5 years ago
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.
5 years ago
nock('https://fetchwithcache.metamask.io')
.get('/price')
.delay(100)
.reply(200, '{"average": 4}')
Update fetchWithCacheTests to use assert.rejects (#8334)
5 years ago
await assert.rejects(
[RFC] add prettier to eslint (#8595)
4 years ago
() =>
fetchWithCache(
'https://fetchwithcache.metamask.io/price',
{},
{ timeout: 20 },
),
Update fetchWithCacheTests to use assert.rejects (#8334)
5 years ago
{ 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.
5 years ago
})
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
5 years ago
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.
5 years ago
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(500, '{"average": 6}')
[RFC] add prettier to eslint (#8595)
4 years ago
await assert.rejects(() =>
fetchWithCache('https://fetchwithcache.metamask.io/price'),
Update fetchWithCacheTests to use assert.rejects (#8334)
5 years ago
)
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.
5 years ago
})
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
5 years ago
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.
5 years ago
nock('https://fetchwithcache.metamask.io')
.post('/price')
.reply(200, '{"average": 7}')
[RFC] add prettier to eslint (#8595)
4 years ago
await assert.rejects(() =>
fetchWithCache('https://fetchwithcache.metamask.io/price', {
method: 'POST',
}),
Update fetchWithCacheTests to use assert.rejects (#8334)
5 years ago
)
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.
5 years ago
})
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
5 years ago
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.
5 years ago
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 8}')
[RFC] add prettier to eslint (#8595)
4 years ago
await assert.rejects(() =>
fetchWithCache('https://fetchwithcache.metamask.io/price', { body: 1 }),
Update fetchWithCacheTests to use assert.rejects (#8334)
5 years ago
)
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.
5 years ago
})
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
5 years ago
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.
5 years ago
nock('https://fetchwithcache.metamask.io')
.get('/price')
.reply(200, '{"average": 9}')
Update fetchWithCacheTests to use assert.rejects (#8334)
5 years ago
await assert.rejects(
[RFC] add prettier to eslint (#8595)
4 years ago
() =>
fetchWithCache('https://fetchwithcache.metamask.io/price', {
headers: { 'Content-Type': 'text/plain' },
}),
Update fetchWithCacheTests to use assert.rejects (#8334)
5 years ago
{ 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.
5 years ago
})
Fix `fetch-with-cache` handling of interwoven requests (#10079) A data race was introduced in #9919 when the old synchronous storage API was replaced with an async storage API. The problem arises when `fetchWithCache` is called a second time while it's still processing another call. In this case, the `cachedFetch` object can become stale while blocked waiting for a fetch response, and result in a cache being overwritten unintentionally. See this example (options omitted for simplicity, and assuming an empty initial cache): ``` await Promise.all([ fetchWithCache('https://metamask.io/foo'), fetchWithCache('https://metamask.io/bar'), ] ``` The order of events could be as follows: 1. Empty cache retrieved for `/foo` route 2. Empty cache retrieved for `/bar` route 3. Call made to `/foo` route 4. Call made to `/bar` route 5. `/foo` response is added to the empty cache object retrieved in step 1, then is saved in the cache. 6. `/bar` response is added to the empty cache object retrieved in step 2, then is saved in the cache. In step 6, the cache object saved would not contain the `/foo` response set in step 5. As a result, `/foo` would never be cached. This problem was resolved by embedding the URL being cached directly in the cache key. This prevents simultaneous responses from overwriting each others caches. Technically a data race still exists when handing simultaneous responses to the same route, but the result would be that the last call to finish would overwrite the previous. This seems acceptable.
4 years ago
it('should correctly cache responses from interwoven requests', async function () {
nock('https://fetchwithcache.metamask.io')
.get('/foo')
.reply(200, '{"average": 9}')
nock('https://fetchwithcache.metamask.io')
.get('/bar')
.reply(200, '{"average": 9}')
const testCache = {}
fakeStorage.getStorageItem.callsFake((key) => testCache[key])
fakeStorage.setStorageItem.callsFake((key, value) => {
testCache[key] = value
})
await Promise.all([
fetchWithCache(
'https://fetchwithcache.metamask.io/foo',
{},
{ cacheRefreshTime: 123 },
),
fetchWithCache(
'https://fetchwithcache.metamask.io/bar',
{},
{ cacheRefreshTime: 123 },
),
])
assert.deepStrictEqual(
testCache['cachedFetch:https://fetchwithcache.metamask.io/foo']
.cachedResponse,
{ average: 9 },
)
assert.deepStrictEqual(
testCache['cachedFetch:https://fetchwithcache.metamask.io/bar']
.cachedResponse,
{ average: 9 },
)
})
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.
5 years ago
})