beforeEach(() => {
    mock_reset();
    mock_get('/users', dataCollectionUsers);

    schema = createSchema();
    schema.addLeaf(createSchemaCollection('users'));
  });

          it('should correctly fetch', () => {
            mock_get('/rules', dataRules);

            return invokeTestHelper(IActionType.get, schema.rules.__stack, {
              expectedSignal: dataRules
            });
          });

          .then(() => {
            expect(resource.hasData()).to.equal(true);

            mock_get('/users', dataCollectionUsers);
            resource.get();

            expect(resource.hasData()).to.equal(true);

            return wait_for_promise(() => resource.status === IStatus.complete)
              .then(() => {
                expect(resource.hasData()).to.equal(true);
              });
          });

        it('should invoke a `get` descriptor', () => {
          const resource = new Resource(schema.users, new RefraxOptions({ noFetchGet: true }));

          mock_get('/users', dataCollectionUsers);

          const fragment = resource._fetchFragment({ noFetchGet: true, fragmentOnly: true }) as FragmentResult;
          expect(fragment.data).to.equal(null);

          return resource.get().then(([result, _response, _descriptor]: TRequestResult) => {
            expect(result).is.instanceof(FragmentResult);
            expect(result.data).to.deep.equal(dataCollectionUsers);
          });
        });

              .then(() => {
                mock_get('/users', dataCollectionUsers);

                expect(mock_request_count()).to.equal(0);

                // re-enable fetch get
                resource._options.noFetchGet = false;

                const result = resource._fetchFragment({ noFetchGet: true });
                expect(result).is.instanceof(FragmentResult);

                return delay_for()()
                  .then(() => {
                    expect(mock_request_count()).to.equal(0);
                  });
              });

      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
            });
          });
      });