From 47e3361c4f08c6548c21a6b21b187d1a6327949e Mon Sep 17 00:00:00 2001
From: Aiden McClelland <me@drbonez.dev>
Date: Tue, 8 Dec 2020 11:55:39 -0700
Subject: [PATCH] config test

---
 ui/src/app/app-config/config-cursor.ts |   2 +-
 ui/test/config.test.ts                 | 263 +++++++++++++++++++++++++
 2 files changed, 264 insertions(+), 1 deletion(-)
 create mode 100644 ui/test/config.test.ts

diff --git a/ui/src/app/app-config/config-cursor.ts b/ui/src/app/app-config/config-cursor.ts
index 99ae5ce0b..b7b63558a 100644
--- a/ui/src/app/app-config/config-cursor.ts
+++ b/ui/src/app/app-config/config-cursor.ts
@@ -454,7 +454,7 @@ function isEqual (uniqueBy: UniqueBy, lhs: ConfigCursor<'object'>, rhs: ConfigCu
   }
 }
 
-function displayUniqueBy(uniqueBy: UniqueBy, spec: ValueSpecObject | ValueSpecUnion, value: object): string {
+export function displayUniqueBy(uniqueBy: UniqueBy, spec: ValueSpecObject | ValueSpecUnion, value: object): string {
   if (typeof uniqueBy === 'string') {
     if (spec.type === 'object') {
       return spec.spec[uniqueBy].name
diff --git a/ui/test/config.test.ts b/ui/test/config.test.ts
new file mode 100644
index 000000000..3a00be3c9
--- /dev/null
+++ b/ui/test/config.test.ts
@@ -0,0 +1,263 @@
+import { displayUniqueBy } from '../src/app/app-config/config-cursor'
+
+function assert(predicate: boolean, message: string) {
+    if (!predicate) {
+        throw new Error('Assertion Failed: ' + message)
+    }
+}
+
+function assertEq(a: any, b: any, message: string) {
+    assert(a === b, message)
+}
+
+function test() {
+    assertEq(
+        displayUniqueBy(
+            'foo',
+            {
+                type: 'object',
+                name: 'Object',
+                spec: {
+                    'foo': {
+                        type: 'string',
+                        name: 'Foo',
+                        nullable: true,
+                        copyable: false,
+                        masked: false,
+                    },
+                },
+                nullByDefault: false,
+                nullable: false,
+                uniqueBy: 'foo'
+            },
+            {
+                foo: 'foo-val',
+            }
+        ),
+        'Foo',
+        'base string uses name mapping'
+    )
+    assertEq(
+        displayUniqueBy(
+            {
+                any: [
+                    'foo',
+                    'bar'
+                ]
+            },
+            {
+                type: 'object',
+                name: 'Object',
+                spec: {
+                    'foo': {
+                        type: 'string',
+                        name: 'Foo',
+                        nullable: true,
+                        copyable: false,
+                        masked: false,
+                    },
+                    'bar': {
+                        type: 'string',
+                        name: 'Bar',
+                        nullable: true,
+                        copyable: false,
+                        masked: false,
+                    },
+                },
+                nullByDefault: false,
+                nullable: false,
+                uniqueBy: {
+                    any: [
+                        'foo',
+                        'bar'
+                    ]
+                }
+            },
+            {
+                foo: 'foo-val',
+                bar: 'bar-val',
+            }
+        ),
+        'Foo and Bar',
+        '`any` must be joined with `and`'
+    )
+    assertEq(
+        displayUniqueBy(
+            {
+                all: [
+                    'foo',
+                    'bar'
+                ]
+            },
+            {
+                type: 'object',
+                name: 'Object',
+                spec: {
+                    'foo': {
+                        type: 'string',
+                        name: 'Foo',
+                        nullable: true,
+                        copyable: false,
+                        masked: false,
+                    },
+                    'bar': {
+                        type: 'string',
+                        name: 'Bar',
+                        nullable: true,
+                        copyable: false,
+                        masked: false,
+                    },
+                },
+                nullByDefault: false,
+                nullable: false,
+                uniqueBy: {
+                    all: [
+                        'foo',
+                        'bar'
+                    ]
+                }
+            },
+            {
+                foo: 'foo-val',
+                bar: 'bar-val',
+            }
+        ),
+        'Foo or Bar',
+        '`all` must be joined with `or`'
+    )
+    assertEq(
+        displayUniqueBy(
+            {
+                any: [
+                    'foo',
+                    {
+                        all: [
+                            'bar',
+                            'baz'
+                        ]
+                    }
+                ]
+            },
+            {
+                type: 'object',
+                name: 'Object',
+                spec: {
+                    'foo': {
+                        type: 'string',
+                        name: 'Foo',
+                        nullable: true,
+                        copyable: false,
+                        masked: false,
+                    },
+                    'bar': {
+                        type: 'string',
+                        name: 'Bar',
+                        nullable: true,
+                        copyable: false,
+                        masked: false,
+                    },
+                    'baz': {
+                        type: 'string',
+                        name: 'Baz',
+                        nullable: true,
+                        copyable: false,
+                        masked: false,
+                    }
+                },
+                nullByDefault: false,
+                nullable: false,
+                uniqueBy: {
+                    any: [
+                        'foo',
+                        {
+                            all: [
+                                'bar',
+                                'baz'
+                            ]
+                        }
+                    ]
+                }
+            },
+            {
+                foo: 'foo-val',
+                bar: 'bar-val',
+                baz: 'baz-val',
+            }
+        ),
+        'Foo and (Bar or Baz)',
+        '`any` of `all` is correct'
+    )
+    assertEq(
+        displayUniqueBy(
+            {
+                any: [
+                    'foo',
+                    {
+                        all: [
+                            'bar',
+                            'baz'
+                        ]
+                    }
+                ]
+            },
+            {
+                type: 'union',
+                name: 'Union',
+                tag: {
+                    id: 'variant',
+                    name: 'Variant',
+                    variantNames: {
+                        'variant-a': 'Variant A',
+                        'variant-b': 'Variant B'
+                    }
+                },
+                variants: {
+                    'variant-a': {
+                        'foo': {
+                            type: 'string',
+                            name: 'Foo',
+                            nullable: true,
+                            copyable: false,
+                            masked: false,
+                        },
+                        'bar': {
+                            type: 'string',
+                            name: 'Bar',
+                            nullable: true,
+                            copyable: false,
+                            masked: false,
+                        },
+                        'baz': {
+                            type: 'string',
+                            name: 'Baz',
+                            nullable: true,
+                            copyable: false,
+                            masked: false,
+                        }
+                    },
+                    'variant-b': {},
+                },
+                uniqueBy: {
+                    any: [
+                        'foo',
+                        {
+                            all: [
+                                'bar',
+                                'baz'
+                            ]
+                        }
+                    ]
+                },
+                default: 'variant-a',
+            },
+            {
+                variant: 'variant-a',
+                foo: 'foo-val',
+                bar: 'bar-val',
+                baz: 'baz-val',
+            }
+        ),
+        'Foo and (Bar or Baz)',
+        'union is correct'
+    )
+}