orc-scripts 1.2.0-pre.0

package/src/config/unexpected-styles.js

@@ -0,0 +1,44 @@
+// const ReactTestUtils = require("react-dom/test-utils");
+
+module.exports = {
+	name: "unexpected-styles",
+	version: "0.0.2",
+	dependencies: ["unexpected-reaction", "unexpected-dom"],
+	installInto: function (expect) {
+		const getStyleDeclarations = selector => {
+			const sheets = document.querySelectorAll("style");
+			let declarations = "";
+			for (let j = 0; j < sheets.length; j += 1) {
+				const sheet = sheets[j].sheet;
+				for (let i = 0; i < sheet.cssRules.length; i += 1) {
+					const ruleSelector = sheet.cssRules[i].selectorText || "";
+					if (ruleSelector.indexOf(selector) !== -1) {
+						declarations += sheet.cssRules[i].cssText;
+					}
+				}
+			}
+			return declarations;
+		};
+
+		expect.addAssertion("<string> as a selector to have style rules <assertion?>", function (expect, selector) {
+			return expect.shift(getStyleDeclarations(selector));
+		});
+
+		expect.addAssertion(
+			"<DOMElement> to have style rules satisfying <assertion>",
+			function (expect, element, ...assertion) {
+				expect.errorMode = "nested";
+				const classes = element.getAttribute("class");
+				if (!classes) {
+					return expect.fail("{0} has no class name", element);
+				}
+				const styleRules = classes
+					.split(" ")
+					.map(sel => getStyleDeclarations("." + sel))
+					.filter(Boolean)
+					.join("\n");
+				return expect.shift(styleRules);
+			},
+		);
+	},
+};

package/src/config/unexpected-styles.test.js

@@ -0,0 +1,118 @@
+import React from "react";
+import styled from "styled-components";
+
+const TestStyled = styled.div`
+	color: red;
+	background-color: green;
+`;
+
+const SvgStyled = styled.svg`
+	height: 10px;
+	width: 100px;
+`;
+
+describe("Styled component plugin for unexpected", () => {
+	let firstSheet, secondSheet;
+	beforeEach(() => {
+		firstSheet = document.createElement("style");
+		firstSheet.appendChild(document.createTextNode(""));
+		document.head.appendChild(firstSheet);
+		const sheet = firstSheet.sheet;
+		sheet.insertRule("html { margin: 0; }", 0);
+		sheet.insertRule("body { padding: 0; }", 1);
+		sheet.insertRule(".foo { color: green; }", 2);
+		secondSheet = document.createElement("style");
+		secondSheet.appendChild(document.createTextNode(""));
+		document.head.appendChild(secondSheet);
+		secondSheet.sheet.insertRule(".bar { color: blue; }", 0);
+	});
+	afterEach(() => {
+		document.head.removeChild(firstSheet);
+		document.head.removeChild(secondSheet);
+	});
+
+	describe("<string> as a selector to have style rules <assertion?>", () => {
+		it("passes when a style matches", () => expect(".foo", "as a selector to have style rules", "to contain", "green"));
+
+		it("works with html tag", () => expect("html", "as a selector to have style rules", "to contain", "margin"));
+
+		it("works with body tag", () => expect("body", "as a selector to have style rules", "to contain", "padding"));
+
+		it("works on a second style sheet", () =>
+			expect(".bar", "as a selector to have style rules", "to contain", "color: blue;"));
+
+		it("gives a decent diff", () =>
+			expect(
+				() => expect(".foo", "as a selector to have style rules", "to contain", "width"),
+				"to throw",
+				"expected '.foo' as a selector to have style rules to contain 'width'\n\n.foo {color: green;}",
+			));
+	});
+
+	describe("<DOMElement> to have style rules satisfying <assertion>", () => {
+		it("passes with DOM element", () =>
+			expect(
+				<div className="ban foo boof" />,
+				"when mounted",
+				"to have style rules satisfying",
+				"to contain",
+				"color: green;",
+			));
+
+		it("passes with DOM element referencing second style sheet", () =>
+			expect(
+				<div className="ban bar boof" />,
+				"when mounted",
+				"to have style rules satisfying",
+				"to contain",
+				"color: blue;",
+			));
+
+		it("passes with SVG element", () =>
+			expect(
+				<SvgStyled />,
+				"when mounted",
+				"to have style rules satisfying",
+				expect.it("to be a", "string").and("to contain", "width: 100px;"),
+			));
+
+		it("passes with a styled component", () =>
+			expect(
+				<TestStyled />,
+				"when mounted",
+				"to have style rules satisfying",
+				expect.it("to be a", "string").and("to contain", "color: red;"),
+			));
+
+		it("gives a detailed diff", () =>
+			expect(
+				() => expect(<TestStyled />, "when mounted", "to have style rules satisfying", "to contain", "color: blue;"),
+				"to throw",
+				new RegExp(
+					'expected <div class="unexpected-stylestest__TestStyled-sc-\\w+-0 [\\w-]+"></div>\n' +
+						"to have style rules satisfying to contain 'color: blue;'\n" +
+						"  expected '\\.\\w+ \\{color: red; background-color: green;\\}' to contain 'color: blue;'\n" +
+						"\n" +
+						"  \\.\\w+ \\{color: red; background-color: green;\\}\n" +
+						"           \\^\\^\\^\\^\\^\\^\\^                \\^\\^\\^\\^\\^\\^\\^",
+				),
+			));
+
+		it("fails if no class name", () =>
+			expect(
+				() => expect(<div id="foo" />, "when mounted", "to have style rules satisfying", "to be ok"),
+				"to throw",
+				'expected <div id="foo"></div> to have style rules satisfying to be ok\n' +
+					'  <div id="foo"></div> has no class name',
+			));
+
+		it("fails if empty class name", () =>
+			expect(
+				() => expect(<div id="foo" className="" />, "when mounted", "to have style rules satisfying", "to be a string"),
+				"to throw",
+				'expected <div id="foo" class=""></div>\n' +
+					"to have style rules satisfying to be a string\n" +
+					'  <div id="foo" class=""></div> has no class name',
+			));
+	});
+});

package/src/config/unexpected.js

@@ -0,0 +1,117 @@
+const unexpected = require("unexpected");
+const unexpectedDom = require("unexpected-dom");
+const unexpectedReaction = require("unexpected-reaction");
+const unexpectedSinon = require("unexpected-sinon");
+const unexpectedImmutable = require("unexpected-immutable");
+const unexpectedStyles = require("./unexpected-styles");
+const unexpectedModule = require("./unexpected-module");
+const unexpectedForm = require("./unexpected-form");
+const React = require("react");
+const Immutable = require("immutable");
+const sinon = require("sinon");
+
+global.expect = unexpected
+	.clone()
+	.use(unexpectedSinon)
+	.use(unexpectedImmutable)
+	.use(unexpectedDom)
+	.use(unexpectedReaction)
+	.use(unexpectedStyles)
+	.use(unexpectedModule)
+	.use(unexpectedForm)
+	.addAssertion(
+		"<array-like> to be shorter than [or same length as] <array-like>",
+		function (expect, subject, pattern) {
+			if (expect.flags["or same length as"]) {
+				return expect(subject.length, "to be less than or equal to", pattern.length);
+			} else {
+				return expect(subject.length, "to be less than", pattern.length);
+			}
+		},
+	)
+	.addAssertion("<function> to be a reducer with initial state <object>", function (expect, subject, initialState) {
+		expect.errorMode = "nested";
+		const oldState = Immutable.Map();
+		return expect(subject, "when called with", [oldState, { type: "NOT_A_USEFUL_ACTION" }], "to be", oldState).and(
+			"when called with",
+			[undefined, { type: "@@INIT" }],
+			"to equal",
+			Immutable.fromJS(initialState),
+		);
+	})
+	.addAssertion("<function> as a React component <assertion?>", function (expect, Subject, assertions) {
+		expect.errorMode = "bubble";
+		try {
+			const element = React.createElement(Subject);
+			return expect.shift(element);
+		} catch (e) {
+			return expect.fail("Could not create element. ", e.message);
+		}
+	})
+	.addAssertion("<any> to be a label", function (expect, subject) {
+		expect.errorMode = "nested";
+		if (typeof subject == "object") {
+			expect(subject, "to satisfy", {
+				id: expect.it("to be a string"),
+				defaultMessage: expect.it("to be a string"),
+			});
+		} else {
+			expect(subject, "to be a string");
+		}
+	})
+	.addAssertion("<object> to be a column definition", function (expect, subject) {
+		if (subject.type === "select") {
+			expect(subject, "to exhaustively satisfy", { type: "select" });
+		} else {
+			const pattern = {
+				fieldName: expect
+					.it("to be a string")
+					.or("to be an array")
+					.and("to have items satisfying", expect.it("to be a string").or("to be a number")),
+			};
+			if (subject.hasOwnProperty("width")) {
+				pattern.width = expect.it("to be a string").and("not to match", /[;:{[]/);
+			}
+			if (subject.hasOwnProperty("type")) {
+				pattern.type = expect
+					.it("to be", "number")
+					.or("to be", "date")
+					.or("to be", "datetime")
+					.or("to be", "currency")
+					.or("to be", "switch")
+					.or("to be", "custom");
+				if (subject.type === "currency") {
+					pattern.currency = expect
+						.it("to be a string")
+						.and("to have length", 3)
+						.or("to be an array")
+						.and("to have items satisfying", "to be a string");
+				}
+				if (subject.type === "switch" && subject.hasOwnProperty("switch")) {
+					pattern.switch = expect.it("to be an object");
+				}
+				if (subject.type === "custom") {
+					pattern.component = expect.it("to be a function");
+					if (subject.hasOwnProperty("funcs")) {
+						pattern.funcs = expect.it("to have values satisfying", "to be a function");
+					}
+				}
+			}
+			if (subject.hasOwnProperty("transform")) {
+				pattern.transform = expect.it("to be a function");
+			}
+			if (subject.hasOwnProperty("label")) {
+				pattern.label = expect.it("to be a label");
+			}
+			if (subject.hasOwnProperty("sort")) {
+				pattern.sort = expect.it("to be a function");
+			}
+			if (subject.hasOwnProperty("defaultValue")) {
+				pattern.defaultValue = expect.it("to be defined");
+			}
+			return expect(subject, "to exhaustively satisfy", pattern);
+		}
+	});
+
+// Add stub for jsdom scrollTo function
+Element.prototype.scrollTo = sinon.stub().named("Element.scrollTo");

package/src/config/unexpected.test.js

@@ -0,0 +1,393 @@
+import React from "react";
+
+const TestComp = () => <div />;
+
+// "<function> to be a reducer with initial state <object>"
+// "<ReactShallowRenderer> has elements <assertion?>"
+// "<ReactElement> renders elements <assertion>"
+// "<function> as a React component <assertion?>"
+
+describe("<any> to be a label", () => {
+	it("passes if subject is a string", () => expect(() => expect("Label", "to be a label"), "not to throw"));
+
+	it("passes if subject is a react-intl descriptor", () =>
+		expect(
+			() =>
+				expect(
+					{
+						id: "foo.test.label",
+						defaultMessage: "Label {foo}",
+						values: { foo: "A" },
+					},
+					"to be a label",
+				),
+			"not to throw",
+		));
+
+	it("fails if subject is not a string or object", () =>
+		expect(
+			() => expect(542, "to be a label"),
+			"to throw",
+			"expected 542 to be a label\n  expected 542 to be a string",
+		));
+
+	it("fails if subject is not a react-intl descriptor", () =>
+		expect(
+			() => expect({ id: "foo.test.label" }, "to be a label"),
+			"to throw",
+			"expected { id: 'foo.test.label' } to be a label\n" +
+				"  expected { id: 'foo.test.label' } to satisfy\n" +
+				"  {\n" +
+				"    id: expect.it('to be a string'),\n" +
+				"    defaultMessage: expect.it('to be a string')\n" +
+				"  }\n" +
+				"\n" +
+				"  {\n" +
+				"    id: 'foo.test.label'\n" +
+				"    // missing: defaultMessage: should be a string\n" +
+				"  }",
+		));
+});
+
+describe("<object> to be a column definition", () => {
+	it("passes with a select column", () =>
+		expect(() => expect({ type: "select" }, "to be a column definition"), "not to throw"));
+
+	it("fails if select column has other parameters", () =>
+		expect(
+			() => expect({ type: "select", label: "select" }, "to be a column definition"),
+			"to throw",
+			"expected { type: 'select', label: 'select' } to be a column definition\n" +
+				"\n" +
+				"{\n" +
+				"  type: 'select',\n" +
+				"  label: 'select' // should be removed\n" +
+				"}",
+		));
+
+	it("passes with no type, string field name", () =>
+		expect(
+			() =>
+				expect(
+					{
+						fieldName: "ColumnA",
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("passes with no type, string field name, width", () =>
+		expect(
+			() =>
+				expect(
+					{
+						fieldName: "ColumnA",
+						width: "400px",
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("fails if width contains suspicious characters", () =>
+		expect(
+			() =>
+				expect(
+					{
+						fieldName: "ColumnA",
+						width: "400px;",
+					},
+					"to be a column definition",
+				),
+			"to throw",
+			"expected { fieldName: 'ColumnA', width: '400px;' } to be a column definition\n" +
+				"\n" +
+				"{\n" +
+				"  fieldName: 'ColumnA',\n" +
+				"  width: '400px;' // ✓ should be a string and\n" +
+				"                  // ⨯ should not match /[;:{[]/\n" +
+				"                  //\n" +
+				"                  //   400px;\n" +
+				"                  //        ^\n" +
+				"}",
+		));
+
+	it("fails if there are unknown parameters", () =>
+		expect(
+			() =>
+				expect(
+					{
+						fieldName: "ColumnA",
+						unknownParam: true,
+					},
+					"to be a column definition",
+				),
+			"to throw",
+			"expected { fieldName: 'ColumnA', unknownParam: true } to be a column definition\n" +
+				"\n" +
+				"{\n" +
+				"  fieldName: 'ColumnA',\n" +
+				"  unknownParam: true // should be removed\n" +
+				"}",
+		));
+
+	it("passes with number type, array field name, transform function", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "number",
+						fieldName: ["rowB", 3, "ColumnA"],
+						transform: x => x * 10,
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("fails if array field name contains non-string non-numbers", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "number",
+						fieldName: [() => "rowB", 3, "ColumnA"],
+					},
+					"to be a column definition",
+				),
+			"to throw",
+			"expected { type: 'number', fieldName: [ () => \"rowB\", 3, 'ColumnA' ] }\n" +
+				"to be a column definition\n" +
+				"\n" +
+				"{\n" +
+				"  type: 'number',\n" +
+				"  fieldName:\n" +
+				"    [ () => \"rowB\", 3, 'ColumnA' ] // ⨯ should be a string\n" +
+				"                                   // or\n" +
+				"                                   // ✓ should be an array and\n" +
+				"                                   // ⨯ should have items satisfying\n" +
+				"                                   //   expect.it('to be a string')\n" +
+				"                                   //         .or('to be a number')\n" +
+				"                                   //\n" +
+				"                                   //   [\n" +
+				'                                   //     () => "rowB", // ⨯ should be a string or\n' +
+				"                                   //                   // ⨯ should be a number\n" +
+				"                                   //     3,\n" +
+				"                                   //     'ColumnA'\n" +
+				"                                   //   ]\n" +
+				"}",
+		));
+
+	it("passes with date type and a string label", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "date",
+						fieldName: "ColumnA",
+						label: "Column A",
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("passes with datetime type and a message descriptor label", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "datetime",
+						fieldName: "ColumnA",
+						label: { id: "test.col_a", defaultMessage: "Column A" },
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("passes with currency type with a string currency and a sort function", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "currency",
+						currency: "USD",
+						fieldName: "ColumnA",
+						sort: () => {},
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("fails if currency type has no currency given", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "currency",
+						fieldName: "ColumnA",
+						sort: () => {},
+					},
+					"to be a column definition",
+				),
+			"to throw",
+			"expected { type: 'currency', fieldName: 'ColumnA', sort: () => {} }\n" +
+				"to be a column definition\n" +
+				"\n" +
+				"{\n" +
+				"  type: 'currency',\n" +
+				"  fieldName: 'ColumnA',\n" +
+				"  sort: () => {}\n" +
+				"  // missing: currency: ⨯ should be a string and\n" +
+				"              ⨯ should have length 3\n" +
+				"              or\n" +
+				"              ⨯ should be an array and\n" +
+				"              ⨯ should have items satisfying 'to be a string'\n" +
+				"}",
+		));
+
+	it("passes with currency type with a data path currency and a default value", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "currency",
+						currency: ["data", "currency"],
+						fieldName: "ColumnA",
+						defaultValue: "12.99",
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("passes with switch type without settings", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "switch",
+						fieldName: "ColumnA",
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("passes with switch type with settings", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "switch",
+						fieldName: "ColumnA",
+						switch: {
+							onCaption: "On",
+							offCaption: "Off",
+						},
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("fails if switch settings found on other type", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "number",
+						fieldName: "ColumnA",
+						switch: {
+							onCaption: "On",
+							offCaption: "Off",
+						},
+					},
+					"to be a column definition",
+				),
+			"to throw",
+			"expected\n" +
+				"{\n" +
+				"  type: 'number',\n" +
+				"  fieldName: 'ColumnA',\n" +
+				"  switch: { onCaption: 'On', offCaption: 'Off' }\n" +
+				"}\n" +
+				"to be a column definition\n" +
+				"\n" +
+				"{\n" +
+				"  type: 'number',\n" +
+				"  fieldName: 'ColumnA',\n" +
+				"  switch: { onCaption: 'On', offCaption: 'Off' } // should be removed\n" +
+				"}",
+		));
+
+	it("passes with custom type without funcs", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "custom",
+						fieldName: "ColumnA",
+						component: TestComp,
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("passes with custom type with funcs", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "custom",
+						fieldName: "ColumnA",
+						component: TestComp,
+						funcs: {
+							test: () => {},
+						},
+					},
+					"to be a column definition",
+				),
+			"not to throw",
+		));
+
+	it("fails if component or funcs on non-custom type", () =>
+		expect(
+			() =>
+				expect(
+					{
+						type: "date",
+						fieldName: "ColumnA",
+						component: TestComp,
+						funcs: {
+							test: () => {},
+						},
+					},
+					"to be a column definition",
+				),
+			"to throw",
+			"expected\n" +
+				"{\n" +
+				"  type: 'date',\n" +
+				"  fieldName: 'ColumnA',\n" +
+				"  component: " +
+				TestComp.toString() +
+				",\n" +
+				"  funcs: { test: () => {} }\n" +
+				"}\n" +
+				"to be a column definition\n" +
+				"\n" +
+				"{\n" +
+				"  type: 'date',\n" +
+				"  fieldName: 'ColumnA',\n" +
+				"  component: " +
+				TestComp.toString() +
+				", // should be removed\n" +
+				"  funcs: { test: () => {} } // should be removed\n" +
+				"}",
+		));
+});