Consider providing a simple runner abstraction, e.g.

[gajus]

Example:

const createRunner = (queryHandlers) => {
  return (query, step) => {
    console.log({
      step,
      sql: query.sql
    });

    const queryHandler = queryHandlers.shift();

    if (!queryHandler) {
      throw new Error('No query handler for step #' + step + '.');
    }

    queryHandler(query);
  };
};

To be used as such:

test('makes one query', async (assert) => {
  const expectedResult = [
    {
      id: 1,
      name: 'a'
    },
    {
      id: 2,
      name: 'b'
    },
    {
      id: 3,
      name: 'c'
    }
  ];

  const runner = createRunner([
    (query) => {
      assert.is(query.sql, 'select `blog`.* from `blog` where `id` in (?, ?, ?)');

      query.response(expectedResult);
    }
  ]);

  tracker.on('query', runner);

  const result = await getBlogsByBlogIds([1, 2, 3]);

  assert.deepEqual(result, expectedResult);
});

[jbrumwell]

Thanks for the suggestion @gajus :) this seems like it may be more of a preference, and may be better left for implementation on a project by project basis. Another approach may be to have an object with tests and results and a single method

const steps = [
  {
    sql : 'BEGIN;'
  },
  {
    test(query) => {
      assert.is(query.bindings, [1, 2, 3]);
    },

    sql : 'select `blog`.* from `blog` where `id` in (?, ?, ?)',

    expected : [
      {
        id: 1,
        name: 'a'
      },
      {
        id: 2,
        name: 'b'
      },
      {
        id: 3,
        name: 'c'
      }
    ]
  },
  {
    sql : 'COMMIT;',
  }
];

tracker.on('query', (query, step) => {
  const runner = steps.shift();

  if (runner.sql) {
    assert.is(runner.sql, query.sql);
  }

  if (runner.test) {
    runner.test(query);
  }

  query.response(runner.expected);
});

In the end there are a lot of ways to abstract these :)

[gajus]

True. Just a suggestion.