don't test primitives

6 files changed, 0 insertions, 808 deletions

diff --git a/test/unit/data/composite/control-flow/exposeConstant.js b/test/unit/data/composite/control-flow/exposeConstant.js
deleted file mode 100644
index 0c75894b..00000000
--- a/test/unit/data/composite/control-flow/exposeConstant.js
+++ /dev/null
@@ -1,42 +0,0 @@
-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
deleted file mode 100644
index 8f6bfd01..00000000
--- a/test/unit/data/composite/control-flow/exposeDependency.js
+++ /dev/null
@@ -1,64 +0,0 @@
-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
deleted file mode 100644
index 9d588e4c..00000000
--- a/test/unit/data/composite/control-flow/withResultOfAvailabilityCheck.js
+++ /dev/null
@@ -1,197 +0,0 @@
-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(11);
-
-  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: -1});
-  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(11);
-
-  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: -1});
-  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(11);
-
-  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, true,  {mode: 'falsy', from: -1});
-  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: mode = index`, t => {
-  t.plan(11);
-
-  quickCompare(t, false, {mode: 'index', from: 'truthy string'});
-  quickCompare(t, true,  {mode: 'index', from: 123});
-  quickCompare(t, false, {mode: 'index', from: true});
-
-  quickCompare(t, false, {mode: 'index', from: ''});
-  quickCompare(t, true,  {mode: 'index', from: 0});
-  quickCompare(t, false, {mode: 'index', from: -1});
-  quickCompare(t, false, {mode: 'index', from: false});
-
-  quickCompare(t, false, {mode: 'index', from: [1, 2, 3]});
-  quickCompare(t, false, {mode: 'index', from: []});
-
-  quickCompare(t, false, {mode: 'index', from: null});
-  quickCompare(t, false, {mode: 'index', 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 index, 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 in step 1 of 2, withResultOfAvailabilityCheck`, cause:
-        {message: `Error computing composition withResultOfAvailabilityCheck`, cause:
-          {message: `Errors in input values provided to withResultOfAvailabilityCheck`, errors: [
-            {message: `mode: Expected one of null empty falsy index, got banana`},
-          ]}}}});
-
-  t.throws(
-    () => composite.expose.compute({
-      from: null,
-      mode: null,
-    }),
-    {message: `Error computing composition`, cause:
-      {message: `Error in step 1 of 2, withResultOfAvailabilityCheck`, 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
deleted file mode 100644
index b81d51a5..00000000
--- a/test/unit/data/composite/data/withPropertiesFromObject.js
+++ /dev/null
@@ -1,241 +0,0 @@
-import t from 'tap';
-import {quickCheckCompositeOutputs} from '#test-lib';
-
-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 qcco = quickCheckCompositeOutputs(t, dependencies);
-
-  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,
-        });
-
-        qcco(step, 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.annotateError.indexInSourceArray')]: 2,
-          message: `Error at zero-index 2: 123`,
-          cause: {
-            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 in step 1 of 2, withPropertiesFromObject`, 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 in step 1 of 2, withPropertiesFromObject`, 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.annotateError.indexInSourceArray')]: 2,
-                message: `Error at zero-index 2: 123`,
-                cause: {
-                  message: `Expected a string, got number`,
-                },
-              },
-            ]},
-          ]}}}});
-});
diff --git a/test/unit/data/composite/data/withPropertyFromObject.js b/test/unit/data/composite/data/withPropertyFromObject.js
deleted file mode 100644
index 068932e2..00000000
--- a/test/unit/data/composite/data/withPropertyFromObject.js
+++ /dev/null
@@ -1,195 +0,0 @@
-import t from 'tap';
-import {quickCheckCompositeOutputs} from '#test-lib';
-
-import CacheableObject from '#cacheable-object';
-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: "internal" input`, t => {
-  t.plan(7);
-
-  const composite = compositeFrom({
-    compose: false,
-
-    steps: [
-      withPropertyFromObject({
-        object: 'object',
-        property: 'property',
-        internal: 'internal',
-      }),
-
-      exposeDependency({dependency: '#value'}),
-    ],
-  });
-
-  const constructor = class extends CacheableObject {
-    static [CacheableObject.propertyDescriptors] = {
-      foo: {
-        flags: {update: true, expose: false},
-      },
-
-      bar: {
-        flags: {update: true, expose: true},
-      },
-
-      baz: {
-        flags: {update: true, expose: true},
-        expose: {
-          transform: baz => baz * 2,
-        },
-      },
-    };
-  };
-
-  constructor.finalizeCacheableObjectPrototype();
-
-  const thing = Reflect.construct(constructor, []);
-
-  thing.foo = 100;
-  thing.bar = 200;
-  thing.baz = 300;
-
-  t.match(composite, {
-    expose: {
-      dependencies: ['object', 'property', 'internal'],
-    },
-  });
-
-  t.equal(composite.expose.compute({
-    object: thing,
-    property: 'foo',
-    internal: true,
-  }), 100);
-
-  t.equal(composite.expose.compute({
-    object: thing,
-    property: 'bar',
-    internal: true,
-  }), 200);
-
-  t.equal(composite.expose.compute({
-    object: thing,
-    property: 'baz',
-    internal: true,
-  }), 300);
-
-  t.equal(composite.expose.compute({
-    object: thing,
-    property: 'baz',
-    internal: false,
-  }), 600);
-
-  t.equal(composite.expose.compute({
-    object: thing,
-    property: 'bimbam',
-    internal: false,
-  }), null);
-
-  t.equal(composite.expose.compute({
-    object: null,
-    property: 'bambim',
-    internal: false,
-  }), 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 qcco = quickCheckCompositeOutputs(t, dependencies);
-
-  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,
-      });
-
-      qcco(step, outputDict);
-    }
-  }
-});
diff --git a/test/unit/data/composite/data/withUniqueItemsOnly.js b/test/unit/data/composite/data/withUniqueItemsOnly.js
deleted file mode 100644
index 50b16f43..00000000
--- a/test/unit/data/composite/data/withUniqueItemsOnly.js
+++ /dev/null
@@ -1,69 +0,0 @@
-import t from 'tap';
-import {quickCheckCompositeOutputs} from '#test-lib';
-
-import {compositeFrom, input} from '#composite';
-import {exposeDependency} from '#composite/control-flow';
-import {withUniqueItemsOnly} from '#composite/data';
-
-t.test(`withUniqueItemsOnly: basic behavior`, t => {
-  t.plan(3);
-
-  const composite = compositeFrom({
-    compose: false,
-
-    steps: [
-      withUniqueItemsOnly({
-        list: 'list',
-      }),
-
-      exposeDependency({dependency: '#list'}),
-    ],
-  });
-
-  t.match(composite, {
-    expose: {
-      dependencies: ['list'],
-    },
-  });
-
-  t.same(composite.expose.compute({
-    list: ['apple', 'banana', 'banana', 'banana', 'apple', 'watermelon'],
-  }), ['apple', 'banana', 'watermelon']);
-
-  t.same(composite.expose.compute({
-    list: [],
-  }), []);
-});
-
-t.test(`withUniqueItemsOnly: output shapes & values`, t => {
-  t.plan(2 * 3 ** 1);
-
-  const dependencies = {
-    ['list_dependency']:
-      [1, 1, 2, 3, 3, 4, 'foo', false, false, 4],
-    [input('list_neither')]:
-      [8, 8, 7, 6, 6, 5, 'bar', true, true, 5],
-  };
-
-  const qcco = quickCheckCompositeOutputs(t, dependencies);
-
-  const mapLevel1 = [
-    ['list_dependency', {
-      '#list_dependency': [1, 2, 3, 4, 'foo', false],
-    }],
-    [input.value([-1, -1, 'interesting', 'very', 'interesting']), {
-      '#uniqueItems': [-1, 'interesting', 'very'],
-    }],
-    [input('list_neither'), {
-      '#uniqueItems': [8, 7, 6, 5, 'bar', true],
-    }],
-  ];
-
-  for (const [listInput, outputDict] of mapLevel1) {
-    const step = withUniqueItemsOnly({
-      list: listInput,
-    });
-
-    qcco(step, outputDict);
-  }
-});