agerix/iconify
2
0
Fork 0
mirror of https://github.com/iconify/iconify.git synced 2025-04-10 18:11:50 +00:00
Code Issues Releases Activity

Simplify redundacy package, allow aborting query with error

Browse Source
This commit is contained in:
Vjacheslav Trushkin 2022-01-25 20:51:09 +02:00
parent abf29e3cd4
commit db883f9593
7 changed files with 182 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
packages/api-redundancy/spec/redundancySpec.mjs
View File

@ -21,7 +21,7 @@ describe('Redundancy class', () => {
const query = redundancy.query(
'/foo',
(resource, payload, status) => {
(resource, payload, callback) => {
counter++;
expect(counter).toBeLessThan(3); // No more than 2 queries should be executed
@ -34,7 +34,7 @@ describe('Redundancy class', () => {
}
// Do something with "data", simulate instant callback
status.done(responses[uri]);
callback('success', responses[uri]);
// Complete test
setTimeout(() => {
@ -78,29 +78,32 @@ describe('Redundancy class', () => {
};
let counter = 0;
const query = redundancy.query('/foo', (resource, payload, status) => {
counter++;
expect(counter).toBeLessThan(2); // Should be success on first call because start index = 1
const query = redundancy.query(
'/foo',
(resource, payload, callback) => {
counter++;
expect(counter).toBeLessThan(2); // Should be success on first call because start index = 1
// Make URI from resource + payload
const uri = resource + payload;
// Make URI from resource + payload
const uri = resource + payload;
// Get fake data if it exists
if (responses[uri] === void 0) {
return;
// Get fake data if it exists
if (responses[uri] === void 0) {
return;
}
// Do something with "data", simulate instant callback
callback('success', responses[uri]);
// Complete test
setTimeout(() => {
expect(counter).toEqual(1);
expect(query().status).toEqual('completed');
expect(redundancy.getIndex()).toEqual(1);
done();
});
}
// Do something with "data", simulate instant callback
status.done(responses[uri]);
// Complete test
setTimeout(() => {
expect(counter).toEqual(1);
expect(query().status).toEqual('completed');
expect(redundancy.getIndex()).toEqual(1);
done();
});
});
);
// Test find()
expect(redundancy.find((item) => item().payload === '/foo')).toEqual(

4
packages/api-redundancy/src/index.ts
View File

@ -13,9 +13,9 @@ import { sendQuery } from './query';
export { GetQueryStatus, QueryModuleCallback, QueryDoneCallback };
export type {
QueryAbortCallback,
QueryUpdateIndexCallback,
QueryStatus,
PendingQueryItem,
QueryModuleResponseType,
QueryModuleResponse,
} from './query';
/**

64
packages/api-redundancy/src/query.ts
View File

@ -11,12 +11,20 @@ type QueryItemStatus = 'pending' | 'completed' | 'aborted' | 'failed';
*/
type QueryPayload = unknown;
/**
* Response from query module
*/
export type QueryModuleResponseData = unknown;
/**
* Callback
*
* If error is present, something went wrong and data is undefined. If error is undefined, data is set.
*/
export type QueryDoneCallback = (data?: unknown, error?: unknown) => void;
export type QueryDoneCallback = (
data?: QueryModuleResponseData,
error?: QueryModuleResponseData
) => void;
/**
* Callback for "abort" pending item.
@ -24,9 +32,13 @@ export type QueryDoneCallback = (data?: unknown, error?: unknown) => void;
export type QueryAbortCallback = () => void;
/**
* Callback to call to update last successful resource index. Used by Resundancy class to automatically update config.
* Response from query module
*/
export type QueryUpdateIndexCallback = (index: number) => void;
export type QueryModuleResponseType = 'success' | 'next' | 'abort';
export type QueryModuleResponse = (
status: QueryModuleResponseType,
data: QueryModuleResponseData
) => void;
/**
* Status for query
@ -52,12 +64,10 @@ export type GetQueryStatus = () => QueryStatus;
/**
* Item in pending items list
*/
export interface PendingQueryItem {
readonly getQueryStatus: GetQueryStatus;
interface PendingQueryItem {
status: QueryItemStatus; // Current query status
readonly resource: RedundancyResource; // Resource
readonly done: QueryDoneCallback; // Function to call with data
abort?: QueryAbortCallback; // Function to call to abort query, set by query handler
readonly callback: QueryModuleResponse; // Function to call with data
}
/**
@ -66,7 +76,7 @@ export interface PendingQueryItem {
export type QueryModuleCallback = (
resource: RedundancyResource,
payload: QueryPayload,
queryItem: PendingQueryItem
callback: QueryModuleResponse
) => void;
/**
@ -74,7 +84,7 @@ export type QueryModuleCallback = (
*/
export function sendQuery(
config: RedundancyConfig,
payload: unknown,
payload: QueryPayload,
query: QueryModuleCallback,
done?: QueryDoneCallback
): GetQueryStatus {
@ -109,7 +119,7 @@ export function sendQuery(
const startTime = Date.now();
let status: QueryItemStatus = 'pending';
let queriesSent = 0;
let lastError: unknown = void 0;
let lastError: QueryModuleResponseData | undefined;
// Timer
let timer: ReturnType<typeof setTimeout> | null = null;
@ -147,9 +157,6 @@ export function sendQuery(
// Abort all queued items
queue.forEach((item) => {
if (item.abort) {
item.abort();
}
if (item.status === 'pending') {
item.status = 'aborted';
}
@ -204,15 +211,12 @@ export function sendQuery(
* Clear queue
*/
function clearQueue(): void {
queue = queue.filter((item) => {
queue.forEach((item) => {
if (item.status === 'pending') {
item.status = 'aborted';
}
if (item.abort) {
item.abort();
}
return false;
});
queue = [];
}
/**
@ -220,10 +224,10 @@ export function sendQuery(
*/
function moduleResponse(
item: PendingQueryItem,
data?: unknown,
error?: unknown
response: QueryModuleResponseType,
data: QueryModuleResponseData
): void {
const isError = data === void 0;
const isError = response !== 'success';
// Remove item from queue
queue = queue.filter((queued) => queued !== item);
@ -247,11 +251,16 @@ export function sendQuery(
return;
}
// Abort
if (response === 'abort') {
lastError = data;
failQuery();
return;
}
// Error
if (isError) {
if (error !== void 0) {
lastError = error;
}
lastError = data;
if (!queue.length) {
if (!resources.length) {
// Nothing else queued, nothing can be queued
@ -320,11 +329,10 @@ export function sendQuery(
// Create new item
const item: PendingQueryItem = {
getQueryStatus,
status: 'pending',
resource,
done: (data?: unknown, error?: unknown) => {
moduleResponse(item, data, error);
callback: (status, data) => {
moduleResponse(item, status, data);
},
};
@ -338,7 +346,7 @@ export function sendQuery(
timer = setTimeout(execNext, config.rotate);
// Execute it
query(resource, payload, item);
query(resource, payload, item.callback);
}
// Execute first query on next tick

93
packages/api-redundancy/tests/advanced-queries-test.ts
View File

@ -1,5 +1,5 @@
import type { RedundancyConfig } from '../src/config';
import type { PendingQueryItem } from '../src/query';
import type { QueryModuleResponse } from '../src/query';
import { sendQuery } from '../src/query';
describe('Advanced queries with multiple resources', () => {
@ -20,14 +20,13 @@ describe('Advanced queries with multiple resources', () => {
let isSync = true;
const startTime = Date.now();
let sentQuery = 0;
let itemAborted = false;
let secondItem: PendingQueryItem;
let secondCallback: QueryModuleResponse;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(queryPayload).toEqual(payload);
@ -36,7 +35,6 @@ describe('Advanced queries with multiple resources', () => {
expect(resource).toEqual(resources[sentQuery]);
// Check status
expect(queryItem.getQueryStatus).toEqual(getStatus);
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.payload).toEqual(payload);
@ -51,13 +49,6 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesSent).toEqual(1);
expect(status.queriesPending).toEqual(1);
// Add abort
queryItem.abort = (): void => {
done(
'Abort should have not been called for first item'
);
};
// Fail in 20ms
setTimeout(() => {
// Status should not have changed
@ -66,7 +57,7 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesPending).toEqual(1);
// Fail
queryItem.done(void 0, true);
callback('next', true);
}, 20);
return;
@ -75,15 +66,8 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesSent).toEqual(2);
expect(status.queriesPending).toEqual(1);
// Add abort
queryItem.abort = (): void => {
done(
'Abort should have not been called for second item'
);
};
// Save item
secondItem = queryItem;
secondCallback = callback;
return;
case 3:
@ -91,16 +75,8 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesSent).toEqual(3);
expect(status.queriesPending).toEqual(2);
// Add abort
queryItem.abort = (): void => {
// This item should be aborted, but only once
expect(itemAborted).toEqual(false);
expect(sentQuery).toEqual(3);
itemAborted = true;
};
// Complete second item
secondItem.done(result);
secondCallback('success', result);
return;
default:
@ -111,9 +87,6 @@ describe('Advanced queries with multiple resources', () => {
// Make sure queries were sent
expect(sentQuery).toEqual(3);
// Third query should have been aborted
expect(itemAborted).toEqual(true);
// Validate data
expect(data).toEqual(result);
expect(error).toBeUndefined();
@ -159,14 +132,13 @@ describe('Advanced queries with multiple resources', () => {
let isSync = true;
const startTime = Date.now();
let sentQuery = 0;
let itemAborted = false;
let firstItem: PendingQueryItem;
let firstCallback: QueryModuleResponse;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(queryPayload).toEqual(payload);
@ -175,7 +147,6 @@ describe('Advanced queries with multiple resources', () => {
expect(resource).toEqual(resources[sentQuery]);
// Check status
expect(queryItem.getQueryStatus).toEqual(getStatus);
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.payload).toEqual(payload);
@ -190,15 +161,8 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesSent).toEqual(1);
expect(status.queriesPending).toEqual(1);
// Add abort
queryItem.abort = (): void => {
done(
'Abort should have not been called for first item'
);
};
// Store item
firstItem = queryItem;
// Store callback
firstCallback = callback;
return;
case 2:
@ -206,12 +170,6 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesSent).toEqual(2);
expect(status.queriesPending).toEqual(2);
// Add abort
queryItem.abort = (): void => {
expect(itemAborted).toEqual(false);
itemAborted = true;
};
// Complete first item in 20ms (70ms from start), then second item
setTimeout(() => {
// Check status
@ -220,14 +178,12 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesSent).toEqual(2);
expect(status.queriesPending).toEqual(2);
firstItem.done(result1);
firstCallback('success', result1);
// Complete second item in 30 ms
setTimeout(() => {
expect(queryItem.status).toEqual('aborted');
// Should not change anything because query is already complete
queryItem.done(result2);
callback('success', result2);
// Finish test
done();
@ -243,9 +199,6 @@ describe('Advanced queries with multiple resources', () => {
// Make sure queries were sent
expect(sentQuery).toEqual(2);
// Second query should have been aborted
expect(itemAborted).toEqual(true);
// Validate data
expect(data).toEqual(result1);
expect(error).toBeUndefined();
@ -290,14 +243,14 @@ describe('Advanced queries with multiple resources', () => {
let isSync = true;
const startTime = Date.now();
let sentQuery = 0;
let firstItem: PendingQueryItem;
let firstCallback: QueryModuleResponse;
let completeCount = 0;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(queryPayload).toEqual(payload);
@ -306,7 +259,6 @@ describe('Advanced queries with multiple resources', () => {
expect(resource).toEqual(resources[sentQuery]);
// Check status
expect(queryItem.getQueryStatus).toEqual(getStatus);
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.payload).toEqual(payload);
@ -321,8 +273,8 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesSent).toEqual(1);
expect(status.queriesPending).toEqual(1);
// Store item
firstItem = queryItem;
// Store callback
firstCallback = callback;
return;
case 2:
@ -360,7 +312,7 @@ describe('Advanced queries with multiple resources', () => {
expect(diff > 130 && diff < 170).toEqual(true);
// Send data from first query, which should be ignored because dataAfterTimeout is false
firstItem.done(result);
firstCallback('success', result);
// Complete test
done();
@ -399,14 +351,14 @@ describe('Advanced queries with multiple resources', () => {
let isSync = true;
const startTime = Date.now();
let sentQuery = 0;
let firstItem: PendingQueryItem;
let firstCallback: QueryModuleResponse;
let completeCount = 0;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(queryPayload).toEqual(payload);
@ -415,7 +367,6 @@ describe('Advanced queries with multiple resources', () => {
expect(resource).toEqual(resources[sentQuery]);
// Check status
expect(queryItem.getQueryStatus).toEqual(getStatus);
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.payload).toEqual(payload);
@ -430,8 +381,8 @@ describe('Advanced queries with multiple resources', () => {
expect(status.queriesSent).toEqual(1);
expect(status.queriesPending).toEqual(1);
// Store item
firstItem = queryItem;
// Store callback
firstCallback = callback;
return;
case 2:
@ -469,7 +420,7 @@ describe('Advanced queries with multiple resources', () => {
expect(diff > 130 && diff < 170).toEqual(true);
// Send data from first query
firstItem.done(result);
firstCallback('success', result);
})();
return;

90
packages/api-redundancy/tests/basic-query-test.ts
View File

@ -74,7 +74,7 @@ describe('Basic queries', () => {
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(resource).toEqual(resources[0]);
expect(queryPayload).toEqual(payload);
@ -84,20 +84,14 @@ describe('Basic queries', () => {
sentQuery = true;
// Check status
expect(queryItem.getQueryStatus).toEqual(getStatus);
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.payload).toEqual(payload);
expect(status.queriesSent).toEqual(1);
expect(status.queriesPending).toEqual(1);
// Add abort function
queryItem.abort = (): void => {
done('Abort should have not been called');
};
// Complete
queryItem.done(result);
callback('success', result);
},
(data, error) => {
// Make sure query was sent
@ -152,7 +146,7 @@ describe('Basic queries', () => {
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(resource).toEqual(resources[0]);
expect(queryPayload).toEqual(payload);
@ -161,13 +155,8 @@ describe('Basic queries', () => {
expect(sentQuery).toEqual(false);
sentQuery = true;
// Add abort function
queryItem.abort = (): void => {
done('Abort should have not been called');
};
// Fail
queryItem.done(void 0, result);
callback('next', result);
},
(data, error) => {
// Make sure query was sent
@ -216,13 +205,12 @@ describe('Basic queries', () => {
let isSync = true;
const startTime = Date.now();
let sentQuery = false;
let itemAborted = false;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload) => {
expect(isSync).toEqual(false);
expect(resource).toEqual(resources[0]);
expect(queryPayload).toEqual(payload);
@ -231,12 +219,6 @@ describe('Basic queries', () => {
expect(sentQuery).toEqual(false);
sentQuery = true;
// Add abort function
queryItem.abort = (): void => {
expect(itemAborted).toEqual(false);
itemAborted = true;
};
// Do not do anything
},
(data, error) => {
@ -253,9 +235,6 @@ describe('Basic queries', () => {
expect(status.queriesSent).toEqual(1);
expect(status.queriesPending).toEqual(0);
// Item should have been aborted
expect(itemAborted).toEqual(true);
// Should have been config.rotate + config.timeout
const diff = Date.now() - startTime;
expect(diff).toBeGreaterThan(250);
@ -272,4 +251,63 @@ describe('Basic queries', () => {
isSync = false;
});
it('Abort query', (done) => {
const payload = {};
const resources = ['api1', 'api2', 'api3'];
const config: RedundancyConfig = {
resources,
index: 0,
timeout: 200,
rotate: 100,
random: false,
dataAfterTimeout: false,
};
// Tracking
let isSync = true;
let sentQuery = false;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(resource).toEqual(resources[0]);
expect(queryPayload).toEqual(payload);
// Make sure query was executed only once
expect(sentQuery).toEqual(false);
sentQuery = true;
// Abort
callback('abort', 404);
},
(data, error) => {
// Make sure query was sent
expect(sentQuery).toEqual(true);
// Validate data
expect(data).toBeUndefined();
expect(error).toBe(404);
// Check status
const status = getStatus();
expect(status.status).toEqual('failed');
expect(status.queriesSent).toEqual(1);
expect(status.queriesPending).toEqual(0);
done();
}
);
// Check status
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.queriesSent).toEqual(0);
expect(status.queriesPending).toEqual(0);
isSync = false;
});
});

93
packages/api-redundancy/tests/multiple-resources-test.ts
View File

@ -24,7 +24,7 @@ describe('Multiple resources', () => {
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(resource).toEqual('api1');
expect(queryPayload).toEqual(payload);
@ -34,20 +34,14 @@ describe('Multiple resources', () => {
sentQuery++;
// Check status
expect(queryItem.getQueryStatus).toEqual(getStatus);
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.payload).toEqual(payload);
expect(status.queriesSent).toEqual(1);
expect(status.queriesPending).toEqual(1);
// Add abort function
queryItem.abort = (): void => {
done('Abort should have not been called');
};
// Complete
queryItem.done(result);
callback('success', result);
},
(data, error) => {
// Make sure query was sent
@ -97,13 +91,12 @@ describe('Multiple resources', () => {
let isSync = true;
const startTime = Date.now();
let sentQuery = 0;
let itemAborted = false;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(queryPayload).toEqual(payload);
@ -112,7 +105,6 @@ describe('Multiple resources', () => {
expect(resource).toEqual(resources[sentQuery]);
// Check status
expect(queryItem.getQueryStatus).toEqual(getStatus);
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.payload).toEqual(payload);
@ -124,29 +116,15 @@ describe('Multiple resources', () => {
expect(status.queriesSent).toEqual(sentQuery);
expect(status.queriesPending).toEqual(sentQuery);
// Add abort function
// Time out first, complete second
switch (sentQuery) {
case 1:
queryItem.abort = (): void => {
// First item should be aborted, but only once
expect(itemAborted).toEqual(false);
// When this is executed, counter should have been increased
expect(sentQuery).toEqual(2);
itemAborted = true;
// Do nothing, let it time out
};
// Do nothing, let it time out
return;
case 2:
queryItem.abort = (): void => {
done('Abort should have not been called');
};
// Send result
queryItem.done(result);
callback('success', result);
return;
default:
@ -157,9 +135,6 @@ describe('Multiple resources', () => {
// Make sure queries were sent
expect(sentQuery).toEqual(2);
// First query should have been aborted
expect(itemAborted).toEqual(true);
// Validate data
expect(data).toEqual(result);
expect(error).toBeUndefined();
@ -204,14 +179,12 @@ describe('Multiple resources', () => {
let isSync = true;
const startTime = Date.now();
let sentQuery = 0;
let item1Aborted = false;
let item2Aborted = false;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload, callback) => {
expect(isSync).toEqual(false);
expect(queryPayload).toEqual(payload);
@ -220,7 +193,6 @@ describe('Multiple resources', () => {
expect(resource).toEqual(resources[sentQuery]);
// Check status
expect(queryItem.getQueryStatus).toEqual(getStatus);
const status = getStatus();
expect(status.status).toEqual('pending');
expect(status.payload).toEqual(payload);
@ -235,29 +207,8 @@ describe('Multiple resources', () => {
// Add abort functions
switch (sentQuery) {
case 1:
queryItem.abort = (): void => {
expect(item1Aborted).toEqual(false);
expect(item2Aborted).toEqual(false);
// This should have been executed at the end
expect(sentQuery).toEqual(2);
item1Aborted = true;
// Do not send anything
};
return;
case 2:
queryItem.abort = (): void => {
expect(item1Aborted).toEqual(true);
expect(item2Aborted).toEqual(false);
// This should have been executed at the end
expect(sentQuery).toEqual(2);
item2Aborted = true;
// Do not send anything
};
// Do not send anything
return;
default:
@ -268,10 +219,6 @@ describe('Multiple resources', () => {
// Make sure queries were sent
expect(sentQuery).toEqual(2);
// Queries should have been aborted
expect(item1Aborted).toEqual(true);
expect(item2Aborted).toEqual(true);
// Validate data
expect(data).toBeUndefined();
expect(error).toBeUndefined();
@ -316,14 +263,12 @@ describe('Multiple resources', () => {
let isSync = true;
const startTime = Date.now();
let sentQuery = 0;
let item1Aborted = false;
let item2Aborted = false;
// Send query
const getStatus = sendQuery(
config,
payload,
(resource, queryPayload, queryItem) => {
(resource, queryPayload) => {
expect(isSync).toEqual(false);
expect(queryPayload).toEqual(payload);
@ -333,33 +278,11 @@ describe('Multiple resources', () => {
// Bump counter
sentQuery++;
// Add abort functions
switch (sentQuery) {
case 1:
queryItem.abort = (): void => {
item1Aborted = true;
};
return;
case 2:
queryItem.abort = (): void => {
item2Aborted = true;
};
return;
default:
done('This code should not have been reached');
}
},
(data, error) => {
// Make sure queries were sent
expect(sentQuery).toEqual(2);
// Queries should have been aborted
expect(item1Aborted).toEqual(true);
expect(item2Aborted).toEqual(true);
// Validate data
expect(data).toBeUndefined();
expect(error).toBeUndefined();

47
packages/api-redundancy/tests/redundancy-test.ts
View File

@ -23,7 +23,7 @@ describe('Redundancy class', () => {
const query = redundancy.query(
'/foo',
(resource, payload, status) => {
(resource, payload, callback) => {
counter++;
expect(counter).toBeLessThan(3); // No more than 2 queries should be executed
@ -36,7 +36,7 @@ describe('Redundancy class', () => {
}
// Do something with "data", simulate instant callback
status.done(responses[uri]);
callback('success', responses[uri]);
// Complete test
setTimeout(() => {
@ -80,29 +80,32 @@ describe('Redundancy class', () => {
};
let counter = 0;
const query = redundancy.query('/foo', (resource, payload, status) => {
counter++;
expect(counter).toBeLessThan(2); // Should be success on first call because start index = 1
const query = redundancy.query(
'/foo',
(resource, payload, callback) => {
counter++;
expect(counter).toBeLessThan(2); // Should be success on first call because start index = 1
// Make URI from resource + payload
const uri = (resource as string) + (payload as string);
// Make URI from resource + payload
const uri = (resource as string) + (payload as string);
// Get fake data if it exists
if (responses[uri] === void 0) {
return;
// Get fake data if it exists
if (responses[uri] === void 0) {
return;
}
// Do something with "data", simulate instant callback
callback('success', responses[uri]);
// Complete test
setTimeout(() => {
expect(counter).toEqual(1);
expect(query().status).toEqual('completed');
expect(redundancy.getIndex()).toEqual(1);
done();
});
}
// Do something with "data", simulate instant callback
status.done(responses[uri]);
// Complete test
setTimeout(() => {
expect(counter).toEqual(1);
expect(query().status).toEqual('completed');
expect(redundancy.getIndex()).toEqual(1);
done();
});
});
);
// Test find()
expect(redundancy.find((item) => item().payload === '/foo')).toEqual(