From ab7591e45e7e31b4e2c0e2f81e224672145993fa Mon Sep 17 00:00:00 2001
From: "(quasar) nebula" <qznebula@protonmail.com>
Date: Sun, 1 Oct 2023 17:01:21 -0300
Subject: data, test: refactor utilities into own file
Primarily for more precies test coverage mapping, but also to make
navigation a bit easier and consolidate complex functions with
lots of imports out of the same space as other, more simple or
otherwise specialized files.
---
.../composite/common-utilities/exposeConstant.js | 46 ----
.../composite/common-utilities/exposeDependency.js | 68 ------
.../common-utilities/withPropertiesFromObject.js | 251 ---------------------
.../common-utilities/withPropertyFromObject.js | 125 ----------
.../withResultOfAvailabilityCheck.js | 177 ---------------
.../data/composite/control-flow/exposeConstant.js | 42 ++++
.../composite/control-flow/exposeDependency.js | 64 ++++++
.../control-flow/withResultOfAvailabilityCheck.js | 173 ++++++++++++++
.../composite/data/withPropertiesFromObject.js | 248 ++++++++++++++++++++
.../data/composite/data/withPropertyFromObject.js | 122 ++++++++++
10 files changed, 649 insertions(+), 667 deletions(-)
delete mode 100644 test/unit/data/composite/common-utilities/exposeConstant.js
delete mode 100644 test/unit/data/composite/common-utilities/exposeDependency.js
delete mode 100644 test/unit/data/composite/common-utilities/withPropertiesFromObject.js
delete mode 100644 test/unit/data/composite/common-utilities/withPropertyFromObject.js
delete mode 100644 test/unit/data/composite/common-utilities/withResultOfAvailabilityCheck.js
create mode 100644 test/unit/data/composite/control-flow/exposeConstant.js
create mode 100644 test/unit/data/composite/control-flow/exposeDependency.js
create mode 100644 test/unit/data/composite/control-flow/withResultOfAvailabilityCheck.js
create mode 100644 test/unit/data/composite/data/withPropertiesFromObject.js
create mode 100644 test/unit/data/composite/data/withPropertyFromObject.js
(limited to 'test/unit/data')
diff --git a/test/unit/data/composite/common-utilities/exposeConstant.js b/test/unit/data/composite/common-utilities/exposeConstant.js
deleted file mode 100644
index bfed0951..00000000
--- a/test/unit/data/composite/common-utilities/exposeConstant.js
+++ /dev/null
@@ -1,46 +0,0 @@
-import t from 'tap';
-
-import {
- compositeFrom,
- continuationSymbol,
- exposeConstant,
- input,
-} from '#composite';
-
-t.test(`exposeConstant: basic behavior`, t => {
- t.plan(2);
-
- const composite1 = compositeFrom({
- compose: false,
-
- steps: [
- exposeConstant({
- value: input.value('foo'),
- }),
- ],
- });
-
- t.match(composite1, {
- expose: {
- dependencies: [],
- },
- });
-
- t.equal(composite1.expose.compute(), 'foo');
-});
-
-t.test(`exposeConstant: validate inputs`, t => {
- t.plan(2);
-
- t.throws(
- () => exposeConstant({}),
- {message: `Errors in input options passed to exposeConstant`, errors: [
- {message: `Required these inputs: value`},
- ]});
-
- t.throws(
- () => exposeConstant({value: 'some dependency'}),
- {message: `Errors in input options passed to exposeConstant`, errors: [
- {message: `value: Expected input.value() call, got dependency name`},
- ]});
-});
diff --git a/test/unit/data/composite/common-utilities/exposeDependency.js b/test/unit/data/composite/common-utilities/exposeDependency.js
deleted file mode 100644
index 4f07cc16..00000000
--- a/test/unit/data/composite/common-utilities/exposeDependency.js
+++ /dev/null
@@ -1,68 +0,0 @@
-import t from 'tap';
-
-import {
- compositeFrom,
- continuationSymbol,
- exposeDependency,
- input,
-} from '#composite';
-
-t.test(`exposeDependency: basic behavior`, t => {
- t.plan(4);
-
- const composite1 = compositeFrom({
- compose: false,
-
- steps: [
- exposeDependency({dependency: 'foo'}),
- ],
- });
-
- t.match(composite1, {
- expose: {
- dependencies: ['foo'],
- },
- });
-
- t.equal(composite1.expose.compute({foo: 'bar'}), 'bar');
-
- const composite2 = compositeFrom({
- compose: false,
-
- steps: [
- {
- dependencies: ['foo'],
- compute: (continuation, {foo}) =>
- continuation({'#bar': foo.toUpperCase()}),
- },
-
- exposeDependency({dependency: '#bar'}),
- ],
- });
-
- t.match(composite2, {
- expose: {
- dependencies: ['foo'],
- },
- });
-
- t.equal(composite2.expose.compute({foo: 'bar'}), 'BAR');
-});
-
-t.test(`exposeDependency: validate inputs`, t => {
- t.plan(2);
-
- t.throws(
- () => exposeDependency({}),
- {message: `Errors in input options passed to exposeDependency`, errors: [
- {message: `Required these inputs: dependency`},
- ]});
-
- t.throws(
- () => exposeDependency({
- dependency: input.value('some static value'),
- }),
- {message: `Errors in input options passed to exposeDependency`, errors: [
- {message: `dependency: Expected dependency name, got input.value() call`},
- ]});
-});
diff --git a/test/unit/data/composite/common-utilities/withPropertiesFromObject.js b/test/unit/data/composite/common-utilities/withPropertiesFromObject.js
deleted file mode 100644
index 3431382e..00000000
--- a/test/unit/data/composite/common-utilities/withPropertiesFromObject.js
+++ /dev/null
@@ -1,251 +0,0 @@
-import t from 'tap';
-
-import {
- compositeFrom,
- exposeDependency,
- input,
- withPropertiesFromObject,
-} from '#composite';
-
-const composite = compositeFrom({
- compose: false,
-
- steps: [
- withPropertiesFromObject({
- object: 'object',
- properties: 'properties',
- }),
-
- exposeDependency({dependency: '#object'}),
- ],
-});
-
-t.test(`withPropertiesFromObject: basic behavior`, t => {
- t.plan(4);
-
- t.match(composite, {
- expose: {
- dependencies: ['object', 'properties'],
- },
- });
-
- t.same(
- composite.expose.compute({
- object: {foo: 'bar', bim: 'BOOM', bam: 'baz'},
- properties: ['foo', 'bim'],
- }),
- {foo: 'bar', bim: 'BOOM'});
-
- t.same(
- composite.expose.compute({
- object: {value1: 'uwah', value2: 'arah'},
- properties: ['value1', 'value3'],
- }),
- {value1: 'uwah', value3: null});
-
- t.same(
- composite.expose.compute({
- object: null,
- properties: ['ohMe', 'ohMy', 'ohDear'],
- }),
- {ohMe: null, ohMy: null, ohDear: null});
-});
-
-t.test(`withPropertiesFromObject: output shapes & values`, t => {
- t.plan(2 * 2 * 3 ** 2);
-
- const dependencies = {
- ['object_dependency']:
- {foo: 'apple', bar: 'banana', baz: 'orange'},
- [input('object_neither')]:
- {foo: 'koala', bar: 'okapi', baz: 'mongoose'},
- ['properties_dependency']:
- ['foo', 'bar', 'missing1'],
- [input('properties_neither')]:
- ['foo', 'baz', 'missing3'],
- };
-
- const mapLevel1 = [
- [input.value('prefix_value'), [
- ['object_dependency', [
- ['properties_dependency', {
- '#object': {foo: 'apple', bar: 'banana', missing1: null},
- }],
- [input.value(['bar', 'baz', 'missing2']), {
- '#prefix_value.bar': 'banana',
- '#prefix_value.baz': 'orange',
- '#prefix_value.missing2': null,
- }],
- [input('properties_neither'), {
- '#object': {foo: 'apple', baz: 'orange', missing3: null},
- }]]],
-
- [input.value({foo: 'ouh', bar: 'rah', baz: 'nyu'}), [
- ['properties_dependency', {
- '#object': {foo: 'ouh', bar: 'rah', missing1: null},
- }],
- [input.value(['bar', 'baz', 'missing2']), {
- '#prefix_value.bar': 'rah',
- '#prefix_value.baz': 'nyu',
- '#prefix_value.missing2': null,
- }],
- [input('properties_neither'), {
- '#object': {foo: 'ouh', baz: 'nyu', missing3: null},
- }]]],
-
- [input('object_neither'), [
- ['properties_dependency', {
- '#object': {foo: 'koala', bar: 'okapi', missing1: null},
- }],
- [input.value(['bar', 'baz', 'missing2']), {
- '#prefix_value.bar': 'okapi',
- '#prefix_value.baz': 'mongoose',
- '#prefix_value.missing2': null,
- }],
- [input('properties_neither'), {
- '#object': {foo: 'koala', baz: 'mongoose', missing3: null},
- }]]]]],
-
- [input.value(null), [
- ['object_dependency', [
- ['properties_dependency', {
- '#object': {foo: 'apple', bar: 'banana', missing1: null},
- }],
- [input.value(['bar', 'baz', 'missing2']), {
- '#object_dependency.bar': 'banana',
- '#object_dependency.baz': 'orange',
- '#object_dependency.missing2': null,
- }],
- [input('properties_neither'), {
- '#object': {foo: 'apple', baz: 'orange', missing3: null},
- }]]],
-
- [input.value({foo: 'ouh', bar: 'rah', baz: 'nyu'}), [
- ['properties_dependency', {
- '#object': {foo: 'ouh', bar: 'rah', missing1: null},
- }],
- [input.value(['bar', 'baz', 'missing2']), {
- '#object.bar': 'rah',
- '#object.baz': 'nyu',
- '#object.missing2': null,
- }],
- [input('properties_neither'), {
- '#object': {foo: 'ouh', baz: 'nyu', missing3: null},
- }]]],
-
- [input('object_neither'), [
- ['properties_dependency', {
- '#object': {foo: 'koala', bar: 'okapi', missing1: null},
- }],
- [input.value(['bar', 'baz', 'missing2']), {
- '#object.bar': 'okapi',
- '#object.baz': 'mongoose',
- '#object.missing2': null,
- }],
- [input('properties_neither'), {
- '#object': {foo: 'koala', baz: 'mongoose', missing3: null},
- }]]]]],
- ];
-
- for (const [prefixInput, mapLevel2] of mapLevel1) {
- for (const [objectInput, mapLevel3] of mapLevel2) {
- for (const [propertiesInput, outputDict] of mapLevel3) {
- const step = withPropertiesFromObject({
- prefix: prefixInput,
- object: objectInput,
- properties: propertiesInput,
- });
-
- quickCheckOutputs(step, outputDict);
- }
- }
- }
-
- function quickCheckOutputs(step, outputDict) {
- t.same(
- Object.keys(step.toDescription().outputs),
- Object.keys(outputDict));
-
- const composite = compositeFrom({
- compose: false,
- steps: [step, {
- dependencies: Object.keys(outputDict),
- compute: dependencies => dependencies,
- }],
- });
-
- t.same(
- composite.expose.compute(dependencies),
- outputDict);
- }
-});
-
-t.test(`withPropertiesFromObject: validate static inputs`, t => {
- t.plan(3);
-
- t.throws(
- () => withPropertiesFromObject({}),
- {message: `Errors in input options passed to withPropertiesFromObject`, errors: [
- {message: `Required these inputs: object, properties`},
- ]});
-
- t.throws(
- () => withPropertiesFromObject({
- object: input.value('intriguing'),
- properties: input.value('very'),
- prefix: input.value({yes: 'yup'}),
- }),
- {message: `Errors in input options passed to withPropertiesFromObject`, errors: [
- {message: `object: Expected an object, got string`},
- {message: `properties: Expected an array, got string`},
- {message: `prefix: Expected a string, got object`},
- ]});
-
- t.throws(
- () => withPropertiesFromObject({
- object: input.value([['abc', 1], ['def', 2], [123, 3]]),
- properties: input.value(['abc', 'def', 123]),
- }),
- {message: `Errors in input options passed to withPropertiesFromObject`, errors: [
- {message: `object: Expected an object, got array`},
- {message: `properties: Errors validating array items`, errors: [
- {
- [Symbol.for('hsmusic.decorate.indexInSourceArray')]: 2,
- message: /Expected a string, got number/,
- },
- ]},
- ]});
-});
-
-t.test(`withPropertiesFromObject: validate dynamic inputs`, t => {
- t.plan(2);
-
- t.throws(
- () => composite.expose.compute({
- object: 'intriguing',
- properties: 'onceMore',
- }),
- {message: `Error computing composition`, cause:
- {message: `Error computing composition withPropertiesFromObject`, cause:
- {message: `Errors in input values provided to withPropertiesFromObject`, errors: [
- {message: `object: Expected an object, got string`},
- {message: `properties: Expected an array, got string`},
- ]}}});
-
- t.throws(
- () => composite.expose.compute({
- object: [['abc', 1], ['def', 2], [123, 3]],
- properties: ['abc', 'def', 123],
- }),
- {message: `Error computing composition`, cause:
- {message: `Error computing composition withPropertiesFromObject`, cause:
- {message: `Errors in input values provided to withPropertiesFromObject`, errors: [
- {message: `object: Expected an object, got array`},
- {message: `properties: Errors validating array items`, errors: [
- {
- [Symbol.for('hsmusic.decorate.indexInSourceArray')]: 2,
- message: /Expected a string, got number/,
- },
- ]},
- ]}}});
-});
diff --git a/test/unit/data/composite/common-utilities/withPropertyFromObject.js b/test/unit/data/composite/common-utilities/withPropertyFromObject.js
deleted file mode 100644
index 11487226..00000000
--- a/test/unit/data/composite/common-utilities/withPropertyFromObject.js
+++ /dev/null
@@ -1,125 +0,0 @@
-import t from 'tap';
-
-import {
- compositeFrom,
- exposeDependency,
- input,
- withPropertyFromObject,
-} from '#composite';
-
-t.test(`withPropertyFromObject: basic behavior`, t => {
- t.plan(4);
-
- const composite = compositeFrom({
- compose: false,
-
- steps: [
- withPropertyFromObject({
- object: 'object',
- property: 'property',
- }),
-
- exposeDependency({dependency: '#value'}),
- ],
- });
-
- t.match(composite, {
- expose: {
- dependencies: ['object', 'property'],
- },
- });
-
- t.equal(composite.expose.compute({
- object: {foo: 'bar', bim: 'BOOM'},
- property: 'bim',
- }), 'BOOM');
-
- t.equal(composite.expose.compute({
- object: {value1: 'uwah'},
- property: 'value2',
- }), null);
-
- t.equal(composite.expose.compute({
- object: null,
- property: 'oml where did me object go',
- }), null);
-});
-
-t.test(`withPropertyFromObject: output shapes & values`, t => {
- t.plan(2 * 3 ** 2);
-
- const dependencies = {
- ['object_dependency']:
- {foo: 'apple', bar: 'banana', baz: 'orange'},
- [input('object_neither')]:
- {foo: 'koala', bar: 'okapi', baz: 'mongoose'},
- ['property_dependency']:
- 'foo',
- [input('property_neither')]:
- 'baz',
- };
-
- const mapLevel1 = [
- ['object_dependency', [
- ['property_dependency', {
- '#value': 'apple',
- }],
- [input.value('bar'), {
- '#object_dependency.bar': 'banana',
- }],
- [input('property_neither'), {
- '#value': 'orange',
- }]]],
-
- [input.value({foo: 'ouh', bar: 'rah', baz: 'nyu'}), [
- ['property_dependency', {
- '#value': 'ouh',
- }],
- [input.value('bar'), {
- '#value': 'rah',
- }],
- [input('property_neither'), {
- '#value': 'nyu',
- }]]],
-
- [input('object_neither'), [
- ['property_dependency', {
- '#value': 'koala',
- }],
- [input.value('bar'), {
- '#value': 'okapi',
- }],
- [input('property_neither'), {
- '#value': 'mongoose',
- }]]],
- ];
-
- for (const [objectInput, mapLevel2] of mapLevel1) {
- for (const [propertyInput, outputDict] of mapLevel2) {
- const step = withPropertyFromObject({
- object: objectInput,
- property: propertyInput,
- });
-
- quickCheckOutputs(step, outputDict);
- }
- }
-
- function quickCheckOutputs(step, outputDict) {
- t.same(
- Object.keys(step.toDescription().outputs),
- Object.keys(outputDict));
-
- const composite = compositeFrom({
- compose: false,
- steps: [step, {
- dependencies: Object.keys(outputDict),
- compute: dependencies => dependencies,
- }],
- });
-
- t.same(
- composite.expose.compute(dependencies),
- outputDict);
- }
-});
diff --git a/test/unit/data/composite/common-utilities/withResultOfAvailabilityCheck.js b/test/unit/data/composite/common-utilities/withResultOfAvailabilityCheck.js
deleted file mode 100644
index 50c127d3..00000000
--- a/test/unit/data/composite/common-utilities/withResultOfAvailabilityCheck.js
+++ /dev/null
@@ -1,177 +0,0 @@
-import t from 'tap';
-
-import {
- compositeFrom,
- continuationSymbol,
- input,
- withResultOfAvailabilityCheck,
-} from '#composite';
-
-const composite = compositeFrom({
- compose: false,
-
- steps: [
- withResultOfAvailabilityCheck({
- from: 'from',
- mode: 'mode',
- }).outputs({
- ['#availability']: '#result',
- }),
-
- {
- dependencies: ['#result'],
- compute: ({'#result': result}) => result,
- },
- ],
-});
-
-t.test(`withResultOfAvailabilityCheck: basic behavior`, t => {
- t.plan(1);
-
- t.match(composite, {
- expose: {
- dependencies: ['from', 'mode'],
- },
- });
-});
-
-const quickCompare = (t, expect, {from, mode}) =>
- t.equal(composite.expose.compute({from, mode}), expect);
-
-const quickThrows = (t, {from, mode}) =>
- t.throws(() => composite.expose.compute({from, mode}));
-
-t.test(`withResultOfAvailabilityCheck: mode = null`, t => {
- t.plan(10);
-
- quickCompare(t, true, {mode: 'null', from: 'truthy string'});
- quickCompare(t, true, {mode: 'null', from: 123});
- quickCompare(t, true, {mode: 'null', from: true});
-
- quickCompare(t, true, {mode: 'null', from: ''});
- quickCompare(t, true, {mode: 'null', from: 0});
- quickCompare(t, true, {mode: 'null', from: false});
-
- quickCompare(t, true, {mode: 'null', from: [1, 2, 3]});
- quickCompare(t, true, {mode: 'null', from: []});
-
- quickCompare(t, false, {mode: 'null', from: null});
- quickCompare(t, false, {mode: 'null', from: undefined});
-});
-
-t.test(`withResultOfAvailabilityCheck: mode = empty`, t => {
- t.plan(10);
-
- quickThrows(t, {mode: 'empty', from: 'truthy string'});
- quickThrows(t, {mode: 'empty', from: 123});
- quickThrows(t, {mode: 'empty', from: true});
-
- quickThrows(t, {mode: 'empty', from: ''});
- quickThrows(t, {mode: 'empty', from: 0});
- quickThrows(t, {mode: 'empty', from: false});
-
- quickCompare(t, true, {mode: 'empty', from: [1, 2, 3]});
- quickCompare(t, false, {mode: 'empty', from: []});
-
- quickCompare(t, false, {mode: 'empty', from: null});
- quickCompare(t, false, {mode: 'empty', from: undefined});
-});
-
-t.test(`withResultOfAvailabilityCheck: mode = falsy`, t => {
- t.plan(10);
-
- quickCompare(t, true, {mode: 'falsy', from: 'truthy string'});
- quickCompare(t, true, {mode: 'falsy', from: 123});
- quickCompare(t, true, {mode: 'falsy', from: true});
-
- quickCompare(t, false, {mode: 'falsy', from: ''});
- quickCompare(t, false, {mode: 'falsy', from: 0});
- quickCompare(t, false, {mode: 'falsy', from: false});
-
- quickCompare(t, true, {mode: 'falsy', from: [1, 2, 3]});
- quickCompare(t, false, {mode: 'falsy', from: []});
-
- quickCompare(t, false, {mode: 'falsy', from: null});
- quickCompare(t, false, {mode: 'falsy', from: undefined});
-});
-
-t.test(`withResultOfAvailabilityCheck: default mode`, t => {
- t.plan(1);
-
- const template = withResultOfAvailabilityCheck({
- from: 'foo',
- });
-
- t.match(template.toDescription(), {
- inputMapping: {
- from: input.dependency('foo'),
- mode: input.value('null'),
- },
- });
-});
-
-t.test(`withResultOfAvailabilityCheck: validate static inputs`, t => {
- t.plan(5);
-
- t.throws(
- () => withResultOfAvailabilityCheck({}),
- {message: `Errors in input options passed to withResultOfAvailabilityCheck`, errors: [
- {message: `Required these inputs: from`},
- ]});
-
- t.doesNotThrow(() =>
- withResultOfAvailabilityCheck({
- from: 'dependency1',
- mode: 'dependency2',
- }));
-
- t.doesNotThrow(() =>
- withResultOfAvailabilityCheck({
- from: input.value('some static value'),
- mode: input.value('null'),
- }));
-
- t.throws(
- () => withResultOfAvailabilityCheck({
- from: 'foo',
- mode: input.value('invalid'),
- }),
- {message: `Errors in input options passed to withResultOfAvailabilityCheck`, errors: [
- {message: `mode: Expected one of null empty falsy, got invalid`},
- ]});
-
- t.throws(() =>
- withResultOfAvailabilityCheck({
- from: input.value(null),
- mode: input.value(null),
- }),
- {message: `Errors in input options passed to withResultOfAvailabilityCheck`, errors: [
- {message: `mode: Expected a value, got null`},
- ]});
-});
-
-t.test(`withResultOfAvailabilityCheck: validate dynamic inputs`, t => {
- t.plan(2);
-
- t.throws(
- () => composite.expose.compute({
- from: 'apple',
- mode: 'banana',
- }),
- {message: `Error computing composition`, cause:
- {message: `Error computing composition withResultOfAvailabilityCheck`, cause:
- {message: `Errors in input values provided to withResultOfAvailabilityCheck`, errors: [
- {message: `mode: Expected one of null empty falsy, got banana`},
- ]}}});
-
- t.throws(
- () => composite.expose.compute({
- from: null,
- mode: null,
- }),
- {message: `Error computing composition`, cause:
- {message: `Error computing composition withResultOfAvailabilityCheck`, cause:
- {message: `Errors in input values provided to withResultOfAvailabilityCheck`, errors: [
- {message: `mode: Expected a value, got null`},
- ]}}});
-});
diff --git a/test/unit/data/composite/control-flow/exposeConstant.js b/test/unit/data/composite/control-flow/exposeConstant.js
new file mode 100644
index 00000000..0c75894b
--- /dev/null
+++ b/test/unit/data/composite/control-flow/exposeConstant.js
@@ -0,0 +1,42 @@
+import t from 'tap';
+
+import {compositeFrom, continuationSymbol, input} from '#composite';
+import {exposeConstant} from '#composite/control-flow';
+
+t.test(`exposeConstant: basic behavior`, t => {
+ t.plan(2);
+
+ const composite1 = compositeFrom({
+ compose: false,
+
+ steps: [
+ exposeConstant({
+ value: input.value('foo'),
+ }),
+ ],
+ });
+
+ t.match(composite1, {
+ expose: {
+ dependencies: [],
+ },
+ });
+
+ t.equal(composite1.expose.compute(), 'foo');
+});
+
+t.test(`exposeConstant: validate inputs`, t => {
+ t.plan(2);
+
+ t.throws(
+ () => exposeConstant({}),
+ {message: `Errors in input options passed to exposeConstant`, errors: [
+ {message: `Required these inputs: value`},
+ ]});
+
+ t.throws(
+ () => exposeConstant({value: 'some dependency'}),
+ {message: `Errors in input options passed to exposeConstant`, errors: [
+ {message: `value: Expected input.value() call, got dependency name`},
+ ]});
+});
diff --git a/test/unit/data/composite/control-flow/exposeDependency.js b/test/unit/data/composite/control-flow/exposeDependency.js
new file mode 100644
index 00000000..8f6bfd01
--- /dev/null
+++ b/test/unit/data/composite/control-flow/exposeDependency.js
@@ -0,0 +1,64 @@
+import t from 'tap';
+
+import {compositeFrom, continuationSymbol, input} from '#composite';
+import {exposeDependency} from '#composite/control-flow';
+
+t.test(`exposeDependency: basic behavior`, t => {
+ t.plan(4);
+
+ const composite1 = compositeFrom({
+ compose: false,
+
+ steps: [
+ exposeDependency({dependency: 'foo'}),
+ ],
+ });
+
+ t.match(composite1, {
+ expose: {
+ dependencies: ['foo'],
+ },
+ });
+
+ t.equal(composite1.expose.compute({foo: 'bar'}), 'bar');
+
+ const composite2 = compositeFrom({
+ compose: false,
+
+ steps: [
+ {
+ dependencies: ['foo'],
+ compute: (continuation, {foo}) =>
+ continuation({'#bar': foo.toUpperCase()}),
+ },
+
+ exposeDependency({dependency: '#bar'}),
+ ],
+ });
+
+ t.match(composite2, {
+ expose: {
+ dependencies: ['foo'],
+ },
+ });
+
+ t.equal(composite2.expose.compute({foo: 'bar'}), 'BAR');
+});
+
+t.test(`exposeDependency: validate inputs`, t => {
+ t.plan(2);
+
+ t.throws(
+ () => exposeDependency({}),
+ {message: `Errors in input options passed to exposeDependency`, errors: [
+ {message: `Required these inputs: dependency`},
+ ]});
+
+ t.throws(
+ () => exposeDependency({
+ dependency: input.value('some static value'),
+ }),
+ {message: `Errors in input options passed to exposeDependency`, errors: [
+ {message: `dependency: Expected dependency name, got input.value() call`},
+ ]});
+});
diff --git a/test/unit/data/composite/control-flow/withResultOfAvailabilityCheck.js b/test/unit/data/composite/control-flow/withResultOfAvailabilityCheck.js
new file mode 100644
index 00000000..4c4be04a
--- /dev/null
+++ b/test/unit/data/composite/control-flow/withResultOfAvailabilityCheck.js
@@ -0,0 +1,173 @@
+import t from 'tap';
+
+import {compositeFrom, continuationSymbol, input} from '#composite';
+import {withResultOfAvailabilityCheck} from '#composite/control-flow';
+
+const composite = compositeFrom({
+ compose: false,
+
+ steps: [
+ withResultOfAvailabilityCheck({
+ from: 'from',
+ mode: 'mode',
+ }).outputs({
+ ['#availability']: '#result',
+ }),
+
+ {
+ dependencies: ['#result'],
+ compute: ({'#result': result}) => result,
+ },
+ ],
+});
+
+t.test(`withResultOfAvailabilityCheck: basic behavior`, t => {
+ t.plan(1);
+
+ t.match(composite, {
+ expose: {
+ dependencies: ['from', 'mode'],
+ },
+ });
+});
+
+const quickCompare = (t, expect, {from, mode}) =>
+ t.equal(composite.expose.compute({from, mode}), expect);
+
+const quickThrows = (t, {from, mode}) =>
+ t.throws(() => composite.expose.compute({from, mode}));
+
+t.test(`withResultOfAvailabilityCheck: mode = null`, t => {
+ t.plan(10);
+
+ quickCompare(t, true, {mode: 'null', from: 'truthy string'});
+ quickCompare(t, true, {mode: 'null', from: 123});
+ quickCompare(t, true, {mode: 'null', from: true});
+
+ quickCompare(t, true, {mode: 'null', from: ''});
+ quickCompare(t, true, {mode: 'null', from: 0});
+ quickCompare(t, true, {mode: 'null', from: false});
+
+ quickCompare(t, true, {mode: 'null', from: [1, 2, 3]});
+ quickCompare(t, true, {mode: 'null', from: []});
+
+ quickCompare(t, false, {mode: 'null', from: null});
+ quickCompare(t, false, {mode: 'null', from: undefined});
+});
+
+t.test(`withResultOfAvailabilityCheck: mode = empty`, t => {
+ t.plan(10);
+
+ quickThrows(t, {mode: 'empty', from: 'truthy string'});
+ quickThrows(t, {mode: 'empty', from: 123});
+ quickThrows(t, {mode: 'empty', from: true});
+
+ quickThrows(t, {mode: 'empty', from: ''});
+ quickThrows(t, {mode: 'empty', from: 0});
+ quickThrows(t, {mode: 'empty', from: false});
+
+ quickCompare(t, true, {mode: 'empty', from: [1, 2, 3]});
+ quickCompare(t, false, {mode: 'empty', from: []});
+
+ quickCompare(t, false, {mode: 'empty', from: null});
+ quickCompare(t, false, {mode: 'empty', from: undefined});
+});
+
+t.test(`withResultOfAvailabilityCheck: mode = falsy`, t => {
+ t.plan(10);
+
+ quickCompare(t, true, {mode: 'falsy', from: 'truthy string'});
+ quickCompare(t, true, {mode: 'falsy', from: 123});
+ quickCompare(t, true, {mode: 'falsy', from: true});
+
+ quickCompare(t, false, {mode: 'falsy', from: ''});
+ quickCompare(t, false, {mode: 'falsy', from: 0});
+ quickCompare(t, false, {mode: 'falsy', from: false});
+
+ quickCompare(t, true, {mode: 'falsy', from: [1, 2, 3]});
+ quickCompare(t, false, {mode: 'falsy', from: []});
+
+ quickCompare(t, false, {mode: 'falsy', from: null});
+ quickCompare(t, false, {mode: 'falsy', from: undefined});
+});
+
+t.test(`withResultOfAvailabilityCheck: default mode`, t => {
+ t.plan(1);
+
+ const template = withResultOfAvailabilityCheck({
+ from: 'foo',
+ });
+
+ t.match(template.toDescription(), {
+ inputMapping: {
+ from: input.dependency('foo'),
+ mode: input.value('null'),
+ },
+ });
+});
+
+t.test(`withResultOfAvailabilityCheck: validate static inputs`, t => {
+ t.plan(5);
+
+ t.throws(
+ () => withResultOfAvailabilityCheck({}),
+ {message: `Errors in input options passed to withResultOfAvailabilityCheck`, errors: [
+ {message: `Required these inputs: from`},
+ ]});
+
+ t.doesNotThrow(() =>
+ withResultOfAvailabilityCheck({
+ from: 'dependency1',
+ mode: 'dependency2',
+ }));
+
+ t.doesNotThrow(() =>
+ withResultOfAvailabilityCheck({
+ from: input.value('some static value'),
+ mode: input.value('null'),
+ }));
+
+ t.throws(
+ () => withResultOfAvailabilityCheck({
+ from: 'foo',
+ mode: input.value('invalid'),
+ }),
+ {message: `Errors in input options passed to withResultOfAvailabilityCheck`, errors: [
+ {message: `mode: Expected one of null empty falsy, got invalid`},
+ ]});
+
+ t.throws(() =>
+ withResultOfAvailabilityCheck({
+ from: input.value(null),
+ mode: input.value(null),
+ }),
+ {message: `Errors in input options passed to withResultOfAvailabilityCheck`, errors: [
+ {message: `mode: Expected a value, got null`},
+ ]});
+});
+
+t.test(`withResultOfAvailabilityCheck: validate dynamic inputs`, t => {
+ t.plan(2);
+
+ t.throws(
+ () => composite.expose.compute({
+ from: 'apple',
+ mode: 'banana',
+ }),
+ {message: `Error computing composition`, cause:
+ {message: `Error computing composition withResultOfAvailabilityCheck`, cause:
+ {message: `Errors in input values provided to withResultOfAvailabilityCheck`, errors: [
+ {message: `mode: Expected one of null empty falsy, got banana`},
+ ]}}});
+
+ t.throws(
+ () => composite.expose.compute({
+ from: null,
+ mode: null,
+ }),
+ {message: `Error computing composition`, cause:
+ {message: `Error computing composition withResultOfAvailabilityCheck`, cause:
+ {message: `Errors in input values provided to withResultOfAvailabilityCheck`, errors: [
+ {message: `mode: Expected a value, got null`},
+ ]}}});
+});
diff --git a/test/unit/data/composite/data/withPropertiesFromObject.js b/test/unit/data/composite/data/withPropertiesFromObject.js
new file mode 100644
index 00000000..ead1b9b2
--- /dev/null
+++ b/test/unit/data/composite/data/withPropertiesFromObject.js
@@ -0,0 +1,248 @@
+import t from 'tap';
+
+import {compositeFrom, input} from '#composite';
+import {exposeDependency} from '#composite/control-flow';
+import {withPropertiesFromObject} from '#composite/data';
+
+const composite = compositeFrom({
+ compose: false,
+
+ steps: [
+ withPropertiesFromObject({
+ object: 'object',
+ properties: 'properties',
+ }),
+
+ exposeDependency({dependency: '#object'}),
+ ],
+});
+
+t.test(`withPropertiesFromObject: basic behavior`, t => {
+ t.plan(4);
+
+ t.match(composite, {
+ expose: {
+ dependencies: ['object', 'properties'],
+ },
+ });
+
+ t.same(
+ composite.expose.compute({
+ object: {foo: 'bar', bim: 'BOOM', bam: 'baz'},
+ properties: ['foo', 'bim'],
+ }),
+ {foo: 'bar', bim: 'BOOM'});
+
+ t.same(
+ composite.expose.compute({
+ object: {value1: 'uwah', value2: 'arah'},
+ properties: ['value1', 'value3'],
+ }),
+ {value1: 'uwah', value3: null});
+
+ t.same(
+ composite.expose.compute({
+ object: null,
+ properties: ['ohMe', 'ohMy', 'ohDear'],
+ }),
+ {ohMe: null, ohMy: null, ohDear: null});
+});
+
+t.test(`withPropertiesFromObject: output shapes & values`, t => {
+ t.plan(2 * 2 * 3 ** 2);
+
+ const dependencies = {
+ ['object_dependency']:
+ {foo: 'apple', bar: 'banana', baz: 'orange'},
+ [input('object_neither')]:
+ {foo: 'koala', bar: 'okapi', baz: 'mongoose'},
+ ['properties_dependency']:
+ ['foo', 'bar', 'missing1'],
+ [input('properties_neither')]:
+ ['foo', 'baz', 'missing3'],
+ };
+
+ const mapLevel1 = [
+ [input.value('prefix_value'), [
+ ['object_dependency', [
+ ['properties_dependency', {
+ '#object': {foo: 'apple', bar: 'banana', missing1: null},
+ }],
+ [input.value(['bar', 'baz', 'missing2']), {
+ '#prefix_value.bar': 'banana',
+ '#prefix_value.baz': 'orange',
+ '#prefix_value.missing2': null,
+ }],
+ [input('properties_neither'), {
+ '#object': {foo: 'apple', baz: 'orange', missing3: null},
+ }]]],
+
+ [input.value({foo: 'ouh', bar: 'rah', baz: 'nyu'}), [
+ ['properties_dependency', {
+ '#object': {foo: 'ouh', bar: 'rah', missing1: null},
+ }],
+ [input.value(['bar', 'baz', 'missing2']), {
+ '#prefix_value.bar': 'rah',
+ '#prefix_value.baz': 'nyu',
+ '#prefix_value.missing2': null,
+ }],
+ [input('properties_neither'), {
+ '#object': {foo: 'ouh', baz: 'nyu', missing3: null},
+ }]]],
+
+ [input('object_neither'), [
+ ['properties_dependency', {
+ '#object': {foo: 'koala', bar: 'okapi', missing1: null},
+ }],
+ [input.value(['bar', 'baz', 'missing2']), {
+ '#prefix_value.bar': 'okapi',
+ '#prefix_value.baz': 'mongoose',
+ '#prefix_value.missing2': null,
+ }],
+ [input('properties_neither'), {
+ '#object': {foo: 'koala', baz: 'mongoose', missing3: null},
+ }]]]]],
+
+ [input.value(null), [
+ ['object_dependency', [
+ ['properties_dependency', {
+ '#object': {foo: 'apple', bar: 'banana', missing1: null},
+ }],
+ [input.value(['bar', 'baz', 'missing2']), {
+ '#object_dependency.bar': 'banana',
+ '#object_dependency.baz': 'orange',
+ '#object_dependency.missing2': null,
+ }],
+ [input('properties_neither'), {
+ '#object': {foo: 'apple', baz: 'orange', missing3: null},
+ }]]],
+
+ [input.value({foo: 'ouh', bar: 'rah', baz: 'nyu'}), [
+ ['properties_dependency', {
+ '#object': {foo: 'ouh', bar: 'rah', missing1: null},
+ }],
+ [input.value(['bar', 'baz', 'missing2']), {
+ '#object.bar': 'rah',
+ '#object.baz': 'nyu',
+ '#object.missing2': null,
+ }],
+ [input('properties_neither'), {
+ '#object': {foo: 'ouh', baz: 'nyu', missing3: null},
+ }]]],
+
+ [input('object_neither'), [
+ ['properties_dependency', {
+ '#object': {foo: 'koala', bar: 'okapi', missing1: null},
+ }],
+ [input.value(['bar', 'baz', 'missing2']), {
+ '#object.bar': 'okapi',
+ '#object.baz': 'mongoose',
+ '#object.missing2': null,
+ }],
+ [input('properties_neither'), {
+ '#object': {foo: 'koala', baz: 'mongoose', missing3: null},
+ }]]]]],
+ ];
+
+ for (const [prefixInput, mapLevel2] of mapLevel1) {
+ for (const [objectInput, mapLevel3] of mapLevel2) {
+ for (const [propertiesInput, outputDict] of mapLevel3) {
+ const step = withPropertiesFromObject({
+ prefix: prefixInput,
+ object: objectInput,
+ properties: propertiesInput,
+ });
+
+ quickCheckOutputs(step, outputDict);
+ }
+ }
+ }
+
+ function quickCheckOutputs(step, outputDict) {
+ t.same(
+ Object.keys(step.toDescription().outputs),
+ Object.keys(outputDict));
+
+ const composite = compositeFrom({
+ compose: false,
+ steps: [step, {
+ dependencies: Object.keys(outputDict),
+ compute: dependencies => dependencies,
+ }],
+ });
+
+ t.same(
+ composite.expose.compute(dependencies),
+ outputDict);
+ }
+});
+
+t.test(`withPropertiesFromObject: validate static inputs`, t => {
+ t.plan(3);
+
+ t.throws(
+ () => withPropertiesFromObject({}),
+ {message: `Errors in input options passed to withPropertiesFromObject`, errors: [
+ {message: `Required these inputs: object, properties`},
+ ]});
+
+ t.throws(
+ () => withPropertiesFromObject({
+ object: input.value('intriguing'),
+ properties: input.value('very'),
+ prefix: input.value({yes: 'yup'}),
+ }),
+ {message: `Errors in input options passed to withPropertiesFromObject`, errors: [
+ {message: `object: Expected an object, got string`},
+ {message: `properties: Expected an array, got string`},
+ {message: `prefix: Expected a string, got object`},
+ ]});
+
+ t.throws(
+ () => withPropertiesFromObject({
+ object: input.value([['abc', 1], ['def', 2], [123, 3]]),
+ properties: input.value(['abc', 'def', 123]),
+ }),
+ {message: `Errors in input options passed to withPropertiesFromObject`, errors: [
+ {message: `object: Expected an object, got array`},
+ {message: `properties: Errors validating array items`, errors: [
+ {
+ [Symbol.for('hsmusic.decorate.indexInSourceArray')]: 2,
+ message: /Expected a string, got number/,
+ },
+ ]},
+ ]});
+});
+
+t.test(`withPropertiesFromObject: validate dynamic inputs`, t => {
+ t.plan(2);
+
+ t.throws(
+ () => composite.expose.compute({
+ object: 'intriguing',
+ properties: 'onceMore',
+ }),
+ {message: `Error computing composition`, cause:
+ {message: `Error computing composition withPropertiesFromObject`, cause:
+ {message: `Errors in input values provided to withPropertiesFromObject`, errors: [
+ {message: `object: Expected an object, got string`},
+ {message: `properties: Expected an array, got string`},
+ ]}}});
+
+ t.throws(
+ () => composite.expose.compute({
+ object: [['abc', 1], ['def', 2], [123, 3]],
+ properties: ['abc', 'def', 123],
+ }),
+ {message: `Error computing composition`, cause:
+ {message: `Error computing composition withPropertiesFromObject`, cause:
+ {message: `Errors in input values provided to withPropertiesFromObject`, errors: [
+ {message: `object: Expected an object, got array`},
+ {message: `properties: Errors validating array items`, errors: [
+ {
+ [Symbol.for('hsmusic.decorate.indexInSourceArray')]: 2,
+ message: /Expected a string, got number/,
+ },
+ ]},
+ ]}}});
+});
diff --git a/test/unit/data/composite/data/withPropertyFromObject.js b/test/unit/data/composite/data/withPropertyFromObject.js
new file mode 100644
index 00000000..6a772c36
--- /dev/null
+++ b/test/unit/data/composite/data/withPropertyFromObject.js
@@ -0,0 +1,122 @@
+import t from 'tap';
+
+import {compositeFrom, input} from '#composite';
+import {exposeDependency} from '#composite/control-flow';
+import {withPropertyFromObject} from '#composite/data';
+
+t.test(`withPropertyFromObject: basic behavior`, t => {
+ t.plan(4);
+
+ const composite = compositeFrom({
+ compose: false,
+
+ steps: [
+ withPropertyFromObject({
+ object: 'object',
+ property: 'property',
+ }),
+
+ exposeDependency({dependency: '#value'}),
+ ],
+ });
+
+ t.match(composite, {
+ expose: {
+ dependencies: ['object', 'property'],
+ },
+ });
+
+ t.equal(composite.expose.compute({
+ object: {foo: 'bar', bim: 'BOOM'},
+ property: 'bim',
+ }), 'BOOM');
+
+ t.equal(composite.expose.compute({
+ object: {value1: 'uwah'},
+ property: 'value2',
+ }), null);
+
+ t.equal(composite.expose.compute({
+ object: null,
+ property: 'oml where did me object go',
+ }), null);
+});
+
+t.test(`withPropertyFromObject: output shapes & values`, t => {
+ t.plan(2 * 3 ** 2);
+
+ const dependencies = {
+ ['object_dependency']:
+ {foo: 'apple', bar: 'banana', baz: 'orange'},
+ [input('object_neither')]:
+ {foo: 'koala', bar: 'okapi', baz: 'mongoose'},
+ ['property_dependency']:
+ 'foo',
+ [input('property_neither')]:
+ 'baz',
+ };
+
+ const mapLevel1 = [
+ ['object_dependency', [
+ ['property_dependency', {
+ '#value': 'apple',
+ }],
+ [input.value('bar'), {
+ '#object_dependency.bar': 'banana',
+ }],
+ [input('property_neither'), {
+ '#value': 'orange',
+ }]]],
+
+ [input.value({foo: 'ouh', bar: 'rah', baz: 'nyu'}), [
+ ['property_dependency', {
+ '#value': 'ouh',
+ }],
+ [input.value('bar'), {
+ '#value': 'rah',
+ }],
+ [input('property_neither'), {
+ '#value': 'nyu',
+ }]]],
+
+ [input('object_neither'), [
+ ['property_dependency', {
+ '#value': 'koala',
+ }],
+ [input.value('bar'), {
+ '#value': 'okapi',
+ }],
+ [input('property_neither'), {
+ '#value': 'mongoose',
+ }]]],
+ ];
+
+ for (const [objectInput, mapLevel2] of mapLevel1) {
+ for (const [propertyInput, outputDict] of mapLevel2) {
+ const step = withPropertyFromObject({
+ object: objectInput,
+ property: propertyInput,
+ });
+
+ quickCheckOutputs(step, outputDict);
+ }
+ }
+
+ function quickCheckOutputs(step, outputDict) {
+ t.same(
+ Object.keys(step.toDescription().outputs),
+ Object.keys(outputDict));
+
+ const composite = compositeFrom({
+ compose: false,
+ steps: [step, {
+ dependencies: Object.keys(outputDict),
+ compute: dependencies => dependencies,
+ }],
+ });
+
+ t.same(
+ composite.expose.compute(dependencies),
+ outputDict);
+ }
+});
--
cgit 1.3.0-6-gf8a5