test('#allTransforms - returns all tracked transforms', function(assert) {
    const recordA = { id: 'jupiter', type: 'planet', attributes: { name: 'Jupiter' } };
    const recordB = { id: 'saturn', type: 'planet', attributes: { name: 'Saturn' } };
    const recordC = { id: 'pluto', type: 'planet', attributes: { name: 'Pluto' } };
    const tb = store.transformBuilder;

    const addRecordATransform = buildTransform(tb.addRecord(recordA));
    const addRecordBTransform = buildTransform(tb.addRecord(recordB));
    const addRecordCTransform = buildTransform(tb.addRecord(recordC));

    return all([
      store.sync(addRecordATransform),
      store.sync(addRecordBTransform),
      store.sync(addRecordCTransform)
    ])
      .then(() => {
        assert.deepEqual(
          store.allTransforms(),
          [
            addRecordATransform,
            addRecordBTransform,
            addRecordCTransform
          ],
          'tracks transforms in correct order'
        );
      });
  });

  test('transformLog.clear - clears all transforms from log as well as tracked transforms', async function(assert) {
    const recordA = {
      id: 'jupiter',
      type: 'planet',
      attributes: { name: 'Jupiter' }
    };
    const recordB = {
      id: 'saturn',
      type: 'planet',
      attributes: { name: 'Saturn' }
    };
    const recordC = {
      id: 'pluto',
      type: 'planet',
      attributes: { name: 'Pluto' }
    };
    const tb = source.transformBuilder;

    const addRecordATransform = buildTransform(tb.addRecord(recordA));
    const addRecordBTransform = buildTransform(tb.addRecord(recordB));
    const addRecordCTransform = buildTransform(tb.addRecord(recordC));

    await source.sync(addRecordATransform);
    await source.sync(addRecordBTransform);
    await source.sync(addRecordCTransform);

    await source.transformLog.clear();

    assert.deepEqual(
      source.allTransforms(),
      [],
      'no transforms remain in history'
    );
  });

module('EventLoggingStrategy', function(hooks) {
  const t = new TransformBuilder();
  const tA = buildTransform([t.addRecord({ type: 'planet', id: 'a', attributes: { name: 'a' } })], null, 'a');
  const tB = buildTransform([t.addRecord({ type: 'planet', id: 'b', attributes: { name: 'b' } })], null, 'b');
  const tC = buildTransform([t.addRecord({ type: 'planet', id: 'c', attributes: { name: 'c' } })], null, 'c');

  let eventLoggingStrategy;

  test('can be instantiated', function(assert) {
    eventLoggingStrategy = new EventLoggingStrategy();

    assert.ok(eventLoggingStrategy);
  });

  test('can be added to a coordinator', function(assert) {
    let coordinator = new Coordinator();

    eventLoggingStrategy = new EventLoggingStrategy();

    coordinator.addStrategy(eventLoggingStrategy);

    assert.strictEqual(coordinator.getStrategy('event-logging'), eventLoggingStrategy);
  });

  test('for basic sources, installs `transform` listeners on activatation and removes them on deactivation', function(assert) {
    assert.expect(6);

    class MySource extends Source {}

    let s1 = new MySource({ name: 's1' });
    let s2 = new MySource({ name: 's2' });

    eventLoggingStrategy = new EventLoggingStrategy();

    let coordinator = new Coordinator({ sources: [ s1, s2 ], strategies: [ eventLoggingStrategy ]});

    assert.equal(s1.listeners('transform').length, 0);
    assert.equal(s2.listeners('transform').length, 0);

    return coordinator.activate()
      .then(() => {
        assert.equal(s1.listeners('transform').length, 1);
        assert.equal(s2.listeners('transform').length, 1);

        return coordinator.deactivate();
      })
      .then(() => {
        assert.equal(s1.listeners('transform').length, 0);
        assert.equal(s2.listeners('transform').length, 0);
      });
  });

  // TODO:
  // * test `interfaces` option
  // * test adding sources that support different interfaces to ensure they're inspected properly
});

  async _pull(query: Query): Promise<Transform[]> {
    let operations: Operation[];

    const results = this._cache.query(query);

    if (Array.isArray(results)) {
      operations = results.map(r => {
        return {
          op: 'updateRecord',
          record: r
        };
      });
    } else if (results) {
      operations = [
        {
          op: 'updateRecord',
          record: results
        } as UpdateRecordOperation
      ];
    } else {
      operations = [];
    }

    return [buildTransform(operations)];
  }

    test('addRecord + replaceAttribute => [addRecord]', function(assert) {
      const t = buildTransform([
        tb.addRecord({
          type: 'planet',
          id: 'jupiter',
          attributes: { name: 'Earth' }
        }),
        tb.replaceAttribute(
          { type: 'planet', id: 'jupiter' },
          'atmosphere',
          'gaseous'
        )
      ]);

      assert.deepEqual(getTransformRequests(requestProcessor, t), [
        {
          op: 'addRecord',
          record: {
            type: 'planet',
            id: 'jupiter',
            attributes: { name: 'Earth', atmosphere: 'gaseous' }
          }
        }
      ]);
    });

  /**
   * Merge transforms from a forked source back into a base source.
   *
   * By default, all of the operations from all of the transforms in the forked
   * source's history will be reduced into a single transform. A subset of
   * operations can be selected by specifying the `sinceTransformId` option.
   *
   * The `coalesce` option controls whether operations are coalesced into a
   * minimal equivalent set before being reduced into a transform.
   *
   * @param forkedSource - The source to merge.
   * @param options - Merge options
   * @returns The result of calling `update()` with the forked transforms.
   */
  merge(
    forkedSource: MemorySource,
    options: MemorySourceMergeOptions = {}
  ): Promise<any> {
    let transforms: Transform[];
    if (options.sinceTransformId) {
      transforms = forkedSource.transformsSince(options.sinceTransformId);
    } else {
      transforms = forkedSource.allTransforms();
    }

    let reducedTransform;
    let ops: RecordOperation[] = [];
    transforms.forEach(t => {
      Array.prototype.push.apply(ops, t.operations);
    });

    if (options.coalesce !== false) {
      ops = coalesceRecordOperations(ops);
    }

    reducedTransform = buildTransform(ops, options.transformOptions);

    return this.update(reducedTransform);
  }