https://github.com/batterii/fake-query

Fake Objection query builder for unit tests
https://github.com/batterii/fake-query

Last synced: 9 days ago
JSON representation

Fake Objection query builder for unit tests

• Host: GitHub
• URL: https://github.com/batterii/fake-query
• Owner: Batterii
• Created: 2020-02-06T02:57:43.000Z (almost 5 years ago)
• Default Branch: master
• Last Pushed: 2023-01-11T02:37:58.000Z (almost 2 years ago)
• Last Synced: 2024-08-21T09:43:13.287Z (3 months ago)
• Language: TypeScript
• Size: 1.98 MB
• Stars: 0
• Watchers: 6
• Forks: 0
• Open Issues: 7
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md

Awesome Lists containing this project

README

        
# @batterii/fake-query

This module exposes a fake [Objection][1] query builder for unit tests. It is

built using [Sinon][2] and is intended to be used in conjunction with it.

## The FakeQuery Class

A named export of this module, the `FakeQuery` exposes a fake QueryBuilder

instance on its `builder` property. You can inject the fake into your code under

test by stubbing the static `::query` method on the desired model.

The fake builder automatically creates sinon stubs for any property accessed on

the builder, except for the `#then` and `#catch` methods used to execute the

query and obtain its result, as well as the `#inspect` method which prints out

a string representation of the builder.

Created stubs always return `this`, as all QueryBuilder methods are chainable.

Test code can examine the `stubs` property to write assertions about the query.

Typically, you will want to do a keys assertion on the stubs object, followed by

sinon assertions on the stubs themselves.

By default, the fake builder will neither resolve or reject when executed, as is

normal for sinon stubs. If you want it to resolve or reject, simply involve the

`#resolves` or `#rejects` methods with the desired result value.

Once the fake builder has been executed, it can no longer be changed. If any of

its instance methods are invoked, or if you attempt to change its result with

`#resolves` or `#rejects`, the invoked method will throw. This ensures that your

assertions are always referring to the state of the builder when it was

executed, and not after.

## Example (Using TypeScript, Mocha, and Chai)

```ts

import {FakeQuery} from "@batterii/fake-query";

import {MyModel} from "../path/to/my-model";

import chai from "chai";

import sinon from "sinon";

import sinonChai from "sinon-chai";

chai.use(sinonChai);

const {expect} = chai;

describe('functionUnderTest', function() {

	let qry: FakeQuery;

	beforeEach(function() {

		qry = new FakeQuery();

		// Make sure this stub is cleaned up! See the `afterEach` below.

		sinon.stub(MyModel, "query").returns(qry.builder);

	});

	afterEach(function() {

		sinon.restore();

	});

	it("deletes the things", async function() {

		const deletedThings = [];

		qry.resolves(deletedThings);

		const result = await functionUnderTest();

		expect(MyModel.query).to.be.calledOnce;

		expect(MyModel.query).to.be.calledOn(MyModel);

		expect(MyModel.query).to.be.calledWithExactly();

		expect(qry.stubs).to.have.keys(["delete", "where", "returning"]);

		expect(qry.stubs.delete).to.be.calledOnce;

		expect(qry.stubs.delete).to.be.calledWithExactly();

		expect(qry.stubs.where).to.be.calledOnce;

		expect(qry.stubs.where).to.be.calledWith("id", ">", 42);

		expect(qry.stubs.returning).to.be.calledOnce;

		expect(qry.stubs.returning).to.be.calledWith("*");

		expect(result).to.equal(deletedThings);

	});

});

// Any non-cosmetic changes to this function will cause the above test to fail.

async function functionUnderTest(): Promise {

	return MyModel.query()

		.delete()

		.where('id', '>', 42)

		.returning('*');

}

```

[1]: https://vincit.github.io/objection.js/

[2]: https://sinonjs.org/