_configurable_responses_test.js

// Copyright Titanium I.T. LLC.
import * as ensure from "util/ensure.js";
import * as type from "util/type.js";
import assert from "util/assert.js";
import { ConfigurableResponses } from "util/configurable_responses.js";

describe("ConfigurableResponses", () => {

	describe("object factory", () => {

		it("converts object into configured responses", () => {
			const responses = ConfigurableResponses.mapObject({
				a: 1,
				b: 2,
			}, "my_name");

			assert.deepEqual(responses, {
				a: ConfigurableResponses.create(1, "my_name: a"),
				b: ConfigurableResponses.create(2, "my_name: b"),
			});
		});

		it("doesn't add name if it isn't provided", () => {
			const responses = ConfigurableResponses.mapObject({
				a: 1,
				b: 2,
			});

			assert.deepEqual(responses, {
				a: ConfigurableResponses.create(1),
				b: ConfigurableResponses.create(2),
			});
		});

	});


	describe("single response", () => {

		it("provides the same response forever", () => {
			const { responses } = createResponses({
				configured: 7,
			});

			assert.equal(responses.next(), 7);
			assert.equal(responses.next(), 7);
			assert.equal(responses.next(), 7);
		});

	});


	describe("list of responses", () => {

		it("provides each response in the list", () => {
			const { responses } = createResponses({
				configured: [ 1, 2, 3 ],
			});

			assert.equal(responses.next(), 1);
			assert.equal(responses.next(), 2);
			assert.equal(responses.next(), 3);
		});

		it("doesn't mutate original list", () => {
			const originalList = [ 1, 2, 3 ];
			const { responses } = createResponses({ configured: originalList });

			responses.next();
			assert.deepEqual(originalList, [ 1, 2, 3 ]);
		});

		it("throws error when list runs out", () => {
			const { responses } = createResponses({
				configured: [],
				name: "my_name",
			});

			assert.throws(
				() => responses.next(),
				"No more responses configured in my_name",
			);
		});

		it("doesn't include name if it isn't defined", () => {
			const { responses } = createResponses({
				configured: [],
			});

			assert.throws(
				() => responses.next(),
				"No more responses configured",
			);
		});

		it("isn't affected by original list being mutated", () => {
			const originalList = [ 1, 2, 3 ];
			const { responses } = createResponses({ configured: originalList });

			originalList.push("X");

			assert.equal(responses.next(), 1);
		});

	});

});

function createResponses({
	configured = [],
	name = undefined,
} = {}) {
	ensure.signature(arguments, [[ undefined, {
		configured: [ undefined, ...type.ANY_VALID ],
		name: [ undefined, String ],
	}]]);

	return {
		responses: new ConfigurableResponses(configured, name),
	};
}