test: reorganize data tests a lil

5 files changed, 0 insertions, 563 deletions

diff --git a/test/unit/data/composite/exposeConstant.js b/test/unit/data/composite/common-utilities/exposeConstant.js
index 829dc706..829dc706 100644
--- a/test/unit/data/composite/exposeConstant.js
+++ b/test/unit/data/composite/common-utilities/exposeConstant.js
diff --git a/test/unit/data/composite/exposeDependency.js b/test/unit/data/composite/common-utilities/exposeDependency.js
index 78801343..78801343 100644
--- a/test/unit/data/composite/exposeDependency.js
+++ b/test/unit/data/composite/common-utilities/exposeDependency.js
diff --git a/test/unit/data/composite/withResultOfAvailabilityCheck.js b/test/unit/data/composite/common-utilities/withResultOfAvailabilityCheck.js
index 01220a3a..01220a3a 100644
--- a/test/unit/data/composite/withResultOfAvailabilityCheck.js
+++ b/test/unit/data/composite/common-utilities/withResultOfAvailabilityCheck.js
diff --git a/test/unit/data/composite/compositeFrom.js b/test/unit/data/composite/compositeFrom.js
deleted file mode 100644
index 00296675..00000000
--- a/test/unit/data/composite/compositeFrom.js
+++ /dev/null
@@ -1,345 +0,0 @@
-import t from 'tap';
-
-import {compositeFrom, continuationSymbol, input} from '#composite';
-import {isString} from '#validators';
-
-t.test(`compositeFrom: basic behavior`, t => {
-  t.plan(2);
-
-  const composite = compositeFrom({
-    annotation: `myComposite`,
-    compose: false,
-
-    steps: [
-      {
-        dependencies: ['foo'],
-        compute: (continuation, {foo}) =>
-          continuation({'#bar': foo * 2}),
-      },
-
-      {
-        dependencies: ['#bar', 'baz', 'suffix'],
-        compute: ({'#bar': bar, baz, suffix}) =>
-          baz.repeat(bar) + suffix,
-      },
-    ],
-  });
-
-  t.match(composite, {
-    annotation: `myComposite`,
-
-    flags: {expose: true, compose: false, update: false},
-
-    expose: {
-      dependencies: ['foo', 'baz', 'suffix'],
-      compute: Function,
-      transform: null,
-    },
-
-    update: null,
-  });
-
-  t.equal(
-    composite.expose.compute({
-      foo: 3,
-      baz: 'ba',
-      suffix: 'BOOM',
-    }),
-    'babababababaBOOM');
-});
-
-t.test(`compositeFrom: input-shaped step dependencies`, t => {
-  t.plan(2);
-
-  const composite = compositeFrom({
-    compose: false,
-    steps: [
-      {
-        dependencies: [
-          input.myself(),
-          input.updateValue(),
-        ],
-
-        transform: (updateValue1, {
-          [input.myself()]: me,
-          [input.updateValue()]: updateValue2,
-        }) => ({me, updateValue1, updateValue2}),
-      },
-    ],
-  });
-
-  t.match(composite, {
-    expose: {
-      dependencies: ['this'],
-      transform: Function,
-      compute: null,
-    },
-  });
-
-  const myself = {foo: 'bar'};
-
-  t.same(
-    composite.expose.transform('banana', {
-      this: myself,
-      pomelo: 'delicious',
-    }),
-    {
-      me: myself,
-      updateValue1: 'banana',
-      updateValue2: 'banana',
-    });
-});
-
-t.test(`compositeFrom: dependencies from inputs`, t => {
-  t.plan(3);
-
-  const composite = compositeFrom({
-    annotation: `myComposite`,
-
-    compose: true,
-
-    inputMapping: {
-      foo:      input('bar'),
-      pomelo:   input.value('delicious'),
-      humorous: input.dependency('#mammal'),
-      data:     input.dependency('albumData'),
-      ref:      input.updateValue(),
-    },
-
-    inputDescriptions: {
-      foo:      input(),
-      pomelo:   input(),
-      humorous: input(),
-      data:     input(),
-      ref:      input(),
-    },
-
-    steps: [
-      {
-        dependencies: [
-          input('foo'),
-          input('pomelo'),
-          input('humorous'),
-          input('data'),
-          input('ref'),
-        ],
-
-        compute: (continuation, {
-          [input('foo')]: foo,
-          [input('pomelo')]: pomelo,
-          [input('humorous')]: humorous,
-          [input('data')]: data,
-          [input('ref')]: ref,
-        }) => continuation.exit({foo, pomelo, humorous, data, ref}),
-      },
-    ],
-  });
-
-  t.match(composite, {
-    expose: {
-      dependencies: [
-        input('bar'),
-        '#mammal',
-        'albumData',
-      ],
-
-      transform: Function,
-      compute: null,
-    },
-  });
-
-  const exitData = {};
-  const continuation = {
-    exit(value) {
-      Object.assign(exitData, value);
-      return continuationSymbol;
-    },
-  };
-
-  t.equal(
-    composite.expose.transform('album:bepis', continuation, {
-      [input('bar')]: 'squid time',
-      '#mammal': 'fox',
-      'albumData': ['album1', 'album2'],
-    }),
-    continuationSymbol);
-
-  t.same(exitData, {
-    foo: 'squid time',
-    pomelo: 'delicious',
-    humorous: 'fox',
-    data: ['album1', 'album2'],
-    ref: 'album:bepis',
-  });
-});
-
-t.test(`compositeFrom: update from various sources`, t => {
-  t.plan(3);
-
-  const match = {
-    flags: {update: true, expose: true, compose: false},
-
-    update: {
-      validate: isString,
-      default: 'foo',
-    },
-
-    expose: {
-      transform: Function,
-      compute: null,
-    },
-  };
-
-  t.test(`compositeFrom: update from composition description`, t => {
-    t.plan(2);
-
-    const composite = compositeFrom({
-      compose: false,
-
-      update: {
-        validate: isString,
-        default: 'foo',
-      },
-
-      steps: [
-        {transform: (value, continuation) => continuation(value.repeat(2))},
-        {transform: (value) => `Xx_${value}_xX`},
-      ],
-    });
-
-    t.match(composite, match);
-    t.equal(composite.expose.transform('foo'), `Xx_foofoo_xX`);
-  });
-
-  t.test(`compositeFrom: update from step dependencies`, t => {
-    t.plan(2);
-
-    const composite = compositeFrom({
-      compose: false,
-
-      steps: [
-        {
-          dependencies: [
-            input.updateValue({
-              validate: isString,
-              default: 'foo',
-            }),
-          ],
-
-          compute: ({
-            [input.updateValue()]: value,
-          }) => `Xx_${value.repeat(2)}_xX`,
-        },
-      ],
-    });
-
-    t.match(composite, match);
-    t.equal(composite.expose.transform('foo'), 'Xx_foofoo_xX');
-  });
-
-  t.test(`compositeFrom: update from inputs`, t => {
-    t.plan(3);
-
-    const composite = compositeFrom({
-      inputMapping: {
-        myInput: input.updateValue({
-          validate: isString,
-          default: 'foo',
-        }),
-      },
-
-      inputDescriptions: {
-        myInput: input(),
-      },
-
-      steps: [
-        {
-          dependencies: [input('myInput')],
-          compute: (continuation, {
-            [input('myInput')]: value,
-          }) => continuation({
-            '#value': `Xx_${value.repeat(2)}_xX`,
-          }),
-        },
-
-        {
-          dependencies: ['#value'],
-          transform: (_value, continuation, {'#value': value}) =>
-            continuation(value),
-        },
-      ],
-    });
-
-    let continuationValue = null;
-    const continuation = value => {
-      continuationValue = value;
-      return continuationSymbol;
-    };
-
-    t.match(composite, {
-      ...match,
-
-      flags: {update: true, expose: true, compose: true},
-    });
-
-    t.equal(
-      composite.expose.transform('foo', continuation),
-      continuationSymbol);
-
-    t.equal(continuationValue, 'Xx_foofoo_xX');
-  });
-});
-
-t.test(`compositeFrom: dynamic input validation from type`, t => {
-  t.plan(2);
-
-  const composite = compositeFrom({
-    inputMapping: {
-      string:   input('string'),
-      number:   input('number'),
-      boolean:  input('boolean'),
-      function: input('function'),
-      object:   input('object'),
-      array:    input('array'),
-    },
-
-    inputDescriptions: {
-      string:   input({null: true, type: 'string'}),
-      number:   input({null: true, type: 'number'}),
-      boolean:  input({null: true, type: 'boolean'}),
-      function: input({null: true, type: 'function'}),
-      object:   input({null: true, type: 'object'}),
-      array:    input({null: true, type: 'array'}),
-    },
-
-    outputs: {'#result': '#result'},
-
-    steps: [
-      {compute: continuation => continuation({'#result': 'OK'})},
-    ],
-  });
-
-  const notCalledSymbol = Symbol('continuation not called');
-
-  let continuationValue;
-  const continuation = value => {
-    continuationValue = value;
-    return continuationSymbol;
-  };
-
-  let thrownError;
-
-  try {
-    continuationValue = notCalledSymbol;
-    thrownError = null;
-    composite.expose.compute(continuation, {
-      [input('string')]: 123,
-    });
-  } catch (error) {
-    thrownError = error;
-  }
-
-  t.equal(continuationValue, notCalledSymbol);
-  t.match(thrownError, {
-  });
-});
diff --git a/test/unit/data/composite/templateCompositeFrom.js b/test/unit/data/composite/templateCompositeFrom.js
deleted file mode 100644
index e96b782e..00000000
--- a/test/unit/data/composite/templateCompositeFrom.js
+++ /dev/null
@@ -1,218 +0,0 @@
-import t from 'tap';
-
-import {isString} from '#validators';
-
-import {
-  compositeFrom,
-  continuationSymbol,
-  input,
-  templateCompositeFrom,
-} from '#composite';
-
-t.test(`templateCompositeFrom: basic behavior`, t => {
-  t.plan(1);
-
-  const myCoolUtility = templateCompositeFrom({
-    annotation: `myCoolUtility`,
-
-    inputs: {
-      foo: input(),
-    },
-
-    outputs: ['#bar'],
-
-    steps: () => [
-      {
-        dependencies: [input('foo')],
-        compute: (continuation, {
-          [input('foo')]: foo,
-        }) => continuation({
-          ['#bar']: (typeof foo).toUpperCase()
-        }),
-      },
-    ],
-  });
-
-  const instantiatedTemplate = myCoolUtility({
-    foo: 'color',
-  });
-
-  t.match(instantiatedTemplate.toDescription(), {
-    annotation: `myCoolUtility`,
-
-    inputMapping: {
-      foo: input.dependency('color'),
-    },
-
-    inputDescriptions: {
-      foo: input(),
-    },
-
-    outputs: {
-      '#bar': '#bar',
-    },
-
-    steps: Function,
-  });
-});
-
-t.test(`templateCompositeFrom: validate static input values`, t => {
-  t.plan(3);
-
-  const stub = {
-    annotation: 'stubComposite',
-    outputs: ['#result'],
-    steps: () => [{compute: continuation => continuation({'#result': 'OK'})}],
-  };
-
-  const quickThrows = (t, composite, inputOptions, ...errorMessages) =>
-    t.throws(
-      () => composite(inputOptions),
-      {
-        message: `Errors in input options passed to stubComposite`,
-        errors: errorMessages.map(message => ({message})),
-      });
-
-  t.test(`templateCompositeFrom: validate input token shapes`, t => {
-    t.plan(15);
-
-    const template1 = templateCompositeFrom({
-      ...stub, inputs: {
-        foo: input(),
-      },
-    });
-
-    t.doesNotThrow(
-      () => template1({foo: 'dependency'}));
-
-    t.doesNotThrow(
-      () => template1({foo: input.dependency('dependency')}));
-
-    t.doesNotThrow(
-      () => template1({foo: input.value('static value')}));
-
-    t.doesNotThrow(
-      () => template1({foo: input('outerInput')}));
-
-    t.doesNotThrow(
-      () => template1({foo: input.updateValue()}));
-
-    t.doesNotThrow(
-      () => template1({foo: input.myself()}));
-
-    quickThrows(t, template1,
-      {foo: input.staticValue()},
-      `foo: Expected dependency name or value-providing input() call, got input.staticValue`);
-
-    quickThrows(t, template1,
-      {foo: input.staticDependency()},
-      `foo: Expected dependency name or value-providing input() call, got input.staticDependency`);
-
-    const template2 = templateCompositeFrom({
-      ...stub, inputs: {
-        bar: input.staticDependency(),
-      },
-    });
-
-    t.doesNotThrow(
-      () => template2({bar: 'dependency'}));
-
-    t.doesNotThrow(
-      () => template2({bar: input.dependency('dependency')}));
-
-    quickThrows(t, template2,
-      {bar: input.value(123)},
-      `bar: Expected dependency name, got input.value`);
-
-    quickThrows(t, template2,
-      {bar: input('outOfPlace')},
-      `bar: Expected dependency name, got input`);
-
-    const template3 = templateCompositeFrom({
-      ...stub, inputs: {
-        baz: input.staticValue(),
-      },
-    });
-
-    t.doesNotThrow(
-      () => template3({baz: input.value(1025)}));
-
-    quickThrows(t, template3,
-      {baz: 'dependency'},
-      `baz: Expected input.value() call, got dependency name`);
-
-    quickThrows(t, template3,
-      {baz: input('outOfPlace')},
-      `baz: Expected input.value() call, got input() call`);
-  });
-
-  t.test(`templateCompositeFrom: validate missing / misplaced inputs`, t => {
-    t.plan(1);
-
-    const template = templateCompositeFrom({
-      ...stub, inputs: {
-        foo: input(),
-        bar: input(),
-      },
-    });
-
-    t.throws(
-      () => template({
-        baz: 'aeiou',
-        raz: input.value(123),
-      }),
-      {
-        message: `Errors in input options passed to stubComposite`,
-        errors: [
-          {message: `Unexpected input names: baz, raz`},
-          {message: `Required these inputs: foo, bar`},
-        ],
-      });
-  });
-
-  t.test(`templateCompositeFrom: validate acceptsNull / defaultValue: null`, t => {
-    t.plan(3);
-
-    const template1 = templateCompositeFrom({
-      ...stub, inputs: {
-        foo: input(),
-      },
-    });
-
-    t.throws(
-      () => template1({}),
-      {
-        message: `Errors in input options passed to stubComposite`,
-        errors: [
-          {message: `Required these inputs: foo`},
-        ],
-      },
-      `throws if input missing and not marked specially`);
-
-    const template2 = templateCompositeFrom({
-      ...stub, inputs: {
-        bar: input({acceptsNull: true}),
-      },
-    });
-
-    t.throws(
-      () => template2({}),
-      {
-        message: `Errors in input options passed to stubComposite`,
-        errors: [
-          {message: `Required these inputs: bar`},
-        ],
-      },
-      `throws if input missing even if marked {acceptsNull}`);
-
-    const template3 = templateCompositeFrom({
-      ...stub, inputs: {
-        baz: input({defaultValue: null}),
-      },
-    });
-
-    t.doesNotThrow(
-      () => template3({}),
-      `does not throw if input missing if marked {defaultValue: null}`);
-  });
-});