it('correctly invalidates cache and fetches', () => {
const resource = new Resource(schema.users);
const store = schema.__node.definition.storeMap.getOrCreate('user');
spy(store, 'invalidate');
return wait_for_promise(() => resource.status === IStatus.complete)
.then(() => {
expect(mock_request_count()).to.equal(1);
mock_get('/users', dataCollectionUsers);
resource.invalidate({ foo: 123 });
expect(store.invalidate.callCount).to.equal(1);
expect(store.invalidate.getCall(0).args[1]).to.deep.equal({
foo: 123,
invoker: resource
});
expect(resource.status).to.equal(IStatus.stale);
expect(resource.timestamp).to.equal(ITimestamp.loading);
expect(mock_request_count()).to.equal(1);
})
.then(delay_for_resource_request(resource))
.then(() => {
expect(mock_request_count()).to.equal(2);
expect(resource.status).to.equal(IStatus.complete);
expect(resource.timestamp).to.not.equal(ITimestamp.stale);
});
});
it('should not make request if cached', () => {
const onLoad = spy();
const onChange = spy();
const resource = new Resource(schema.users, new RefraxOptions());
let fragment: FragmentResult;
resource.on('load', onLoad);
resource.on('change', onChange);
return delay_for_resource_request(resource)()
.then(() => {
expect(onLoad.callCount).to.equal(1);
expect(onChange.callCount).to.equal(1);
expect(mock_request_count()).to.equal(1);
expect(resource.data).to.deep.equal(dataCollectionUsers);
expect(resource.status).to.equal(IStatus.complete);
expect(resource.timestamp).to.not.equal(ITimestamp.loading);
fragment = resource._fetchFragment();
})
.then(delay_for())
.then(() => {
expect(fragment).is.instanceof(FragmentResult);
expect(fragment.data).to.deep.equal(dataCollectionUsers);
expect(fragment.status).to.equal(IStatus.complete);
expect(fragment.timestamp).to.not.equal(ITimestamp.loading);
expect(resource.data).to.deep.equal(dataCollectionUsers);
expect(resource.status).to.equal(IStatus.complete);
expect(resource.timestamp).to.not.equal(ITimestamp.loading);
expect(mock_request_count()).to.equal(1);
expect(onLoad.callCount).to.equal(1);
expect(onChange.callCount).to.equal(1);
});
});
it('should look and behave like a Resource', () => {
const onLoad = spy();
const onChange = spy();
const store = schema.__node.definition.storeMap.getOrCreate('user');
spy(store, 'once');
const resource = new Resource(schema.users);
expect(resource)
.to.be.instanceof(Resource);
expect(resource)
.to.have.property('timestamp')
.that.equals(ITimestamp.loading);
expect(resource)
.to.have.property('status')
.that.equals(IStatus.stale);
expect(resource)
.to.have.property('data')
.that.equals(null);
expect(resource)
.to.have.property('_dispatchLoad')
.that.is.a('function');
resource.on('load', onLoad);
resource.on('change', onChange);
expect(store.once.callCount).to.equal(0);
expect(mock_request_count()).to.equal(0);
expect(onLoad.callCount).to.equal(0);
expect(onChange.callCount).to.equal(0);
return delay_for_resource_request(resource)()
.then(() => {
expect(mock_request_count()).to.equal(1);
expect(onLoad.callCount).to.equal(1);
expect(onChange.callCount).to.equal(1);
expect(resource.data).to.deep.equal(dataCollectionUsers);
expect(resource.status).to.equal(IStatus.complete);
expect(resource.timestamp).to.be.greaterThan(ITimestamp.loading);
expect(store.once.callCount).to.equal(0);
const descriptor = new ResourceDescriptor(null, IActionType.get, schema.users.__stack);
store.updateResource(descriptor, dataCollectionUsersUpdate, IStatus.complete);
expect(onLoad.callCount).to.equal(1);
expect(onChange.callCount).to.equal(2);
expect(resource.data).to.deep.equal(dataCollectionUsersUpdate);
expect(resource.status).to.equal(IStatus.complete);
expect(resource.timestamp).to.be.greaterThan(ITimestamp.loading);
});
});
it('properly updates collections when mutated', () => {
mock_get('/users', dataCollectionUsers1);
const resourceUsers = new Resource(schema.users);
const mutableUser = new MutableResource(schema.users.user.withParams({
userId: 1
}));
expect(resourceUsers).to.deep.match({
data: null,
status: IStatus.stale,
timestamp: ITimestamp.loading
});
return delay_for_resource_request(resourceUsers)()
.then(() => {
expect(resourceUsers).to.deep.match({
data: dataCollectionUsers1,
status: IStatus.complete,
timestamp: (val: number) => val > ITimestamp.loading
});
mock_put('/users/1', { id: 1, name: 'bob foo' });
const promiseUpdate = mutableUser.update({ name: 'bob foo' });
// The `touch` event from our `update` does not affect the collection
expect(resourceUsers).to.deep.match({
data: dataCollectionUsers1,
status: IStatus.complete,
timestamp: (val: number) => val > ITimestamp.loading
});
return promiseUpdate;
})
.then(() => {
// The `update` event from our `update` action should update the collection
expect(resourceUsers).to.deep.match({
data: [
{ id: 1, name: 'bob foo' },
dataElement2
],
status: IStatus.complete,
timestamp: (val: number) => val > ITimestamp.loading
});
});
});
it('invokes _fetchFragment and passes arguments', () => {
const resource = new Resource(schema.users, new RefraxOptions({ noFetchGet: true }));
const spyFetchFragment = spy(resource, '_fetchFragment');
const spyDispatchLoad = spy(resource, '_dispatchLoad');
return delay_for()()
.then(() => {
// prove Resource made no request
expect(resource.data).to.equal(null);
expect(resource.status).to.equal(IStatus.stale);
expect(resource.timestamp).to.equal(ITimestamp.stale);
expect(mock_request_count()).to.equal(0);
expect(spyFetchFragment.callCount).to.equal(0);
expect(spyDispatchLoad.callCount).to.equal(0);
// re-enable fetch get
resource._options.noFetchGet = false;
resource._updateCache({ foo: 1 });
expect(spyFetchFragment.callCount).to.equal(1);
expect(spyFetchFragment.getCall(0).args[0]).to.deep.equal({ foo: 1 });
expect(spyDispatchLoad.callCount).to.equal(0);
expect(resource._dispatchLoad).to.equal(spyDispatchLoad);
spyFetchFragment.reset();
})
.then(delay_for_resource_request(resource))
.then(() => {
expect(resource.data).to.deep.equal(dataCollectionUsers);
expect(resource.status).to.equal(IStatus.complete);
expect(resource.timestamp).to.not.equal(ITimestamp.loading);
expect(mock_request_count()).to.equal(1);
expect(spyFetchFragment.callCount).to.equal(1);
expect(spyFetchFragment.getCall(0).args[0]).to.deep.equal({
noPropagate: false,
noFetchGet: false
});
expect(spyDispatchLoad.callCount).to.equal(1);
expect(resource._dispatchLoad).to.equal(null);
});
});
it('should handle loading a failed request', () => {
mock_reset();
mock_get('/users', { error: 'foobar' }, 500);
const onLoad = spy();
const onChange = spy();
const store = schema.__node.definition.storeMap.getOrCreate('user');
spy(store, 'once');
const resource = new Resource(schema.users);
resource.on('load', onLoad);
resource.on('change', onChange);
expect(store.once.callCount).to.equal(0);
expect(mock_request_count()).to.equal(0);
expect(onLoad.callCount).to.equal(0);
expect(onChange.callCount).to.equal(0);
return delay_for_resource_request(resource)()
.then(() => {
expect(mock_request_count()).to.equal(1);
expect(onLoad.callCount).to.equal(0);
expect(onChange.callCount).to.equal(1);
expect(resource.data).to.equal(null);
expect(resource.status).to.equal(IStatus.stale);
expect(resource.timestamp).to.be.greaterThan(ITimestamp.loading);
expect(store.once.callCount).to.equal(0);
const descriptor = new ResourceDescriptor(null, IActionType.get, schema.users.__stack);
store.updateResource(descriptor, dataCollectionUsersUpdate, IStatus.complete);
expect(onLoad.callCount).to.equal(1);
expect(onChange.callCount).to.equal(2);
expect(resource.data).to.deep.equal(dataCollectionUsersUpdate);
expect(resource.status).to.equal(IStatus.complete);
expect(resource.timestamp).to.be.greaterThan(ITimestamp.loading);
});
});