« get me outta code hell

withPropertyFromObject.js « common-utilities « composite « data « unit « test - hsmusic-wiki - HSMusic - static wiki software cataloguing collaborative creation
about summary refs log tree commit diff
path: root/test/unit/data/composite/common-utilities/withPropertyFromObject.js
blob: 11487226e34b8b730ff722b1aad7eb07ffa16043 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
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);
  }
});