src/models/vocabulary.test.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import * as Vocabulary from './vocabulary';
   6 import { pipe } from 'lodash/fp';
   7
   8 describe('Vocabulary', () => {
   9     let vocabulary: Vocabulary.Vocabulary;
  10
  11     beforeEach(() => {
  12         vocabulary = {
  13             strict_tags: false,
  14             tags: {
  15                 IDKEYCOMMENT: {
  16                     labels: []
  17                 },
  18                 IDKEYANIMALS: {
  19                     strict: false,
  20                     labels: [
  21                         {label: "Animal" },
  22                         {label: "Creature"}
  23                     ],
  24                     values: {
  25                         IDVALANIMALS1: {
  26                             labels: [
  27                                 {label: "Human"},
  28                                 {label: "Homo sapiens"}
  29                             ]
  30                         },
  31                         IDVALANIMALS2: {
  32                             labels: [
  33                                 {label: "Dog"},
  34                                 {label: "Canis lupus familiaris"}
  35                             ]
  36                         },
  37                     }
  38                 },
  39                 IDKEYSIZES: {
  40                     labels: [{label: "Sizes"}],
  41                     values: {
  42                         IDVALSIZES1: {
  43                             labels: [{label: "Small"}]
  44                         },
  45                         IDVALSIZES2: {
  46                             labels: [{label: "Medium"}]
  47                         },
  48                         IDVALSIZES3: {
  49                             labels: [{label: "Large"}]
  50                         },
  51                         IDVALSIZES4: {
  52                             labels: []
  53                         }
  54                     }
  55                 }
  56             }
  57         }
  58     });
  59
  60     it('returns the list of tag keys', () => {
  61         const tagKeys = Vocabulary.getTags(vocabulary);
  62         // Alphabetically ordered by label
  63         expect(tagKeys).toEqual([
  64             {id: "IDKEYANIMALS", label: "Animal"},
  65             {id: "IDKEYANIMALS", label: "Creature"},
  66             {id: "IDKEYCOMMENT", label: "IDKEYCOMMENT"},
  67             {id: "IDKEYSIZES", label: "Sizes"},
  68         ]);
  69     });
  70
  71     it('returns the tag values for a given key', () => {
  72         const tagValues = Vocabulary.getTagValues('IDKEYSIZES', vocabulary);
  73         // Alphabetically ordered by label
  74         expect(tagValues).toEqual([
  75             {id: "IDVALSIZES4", label: "IDVALSIZES4"},
  76             {id: "IDVALSIZES3", label: "Large"},
  77             {id: "IDVALSIZES2", label: "Medium"},
  78             {id: "IDVALSIZES1", label: "Small"},
  79         ])
  80     });
  81
  82     it('returns an empty list of values for an non-existent key', () => {
  83         const tagValues = Vocabulary.getTagValues('IDNONSENSE', vocabulary);
  84         expect(tagValues).toEqual([]);
  85     });
  86
  87     it('returns a key id for a given key label', () => {
  88         const testCases = [
  89             // Two labels belonging to the same ID
  90             {keyLabel: 'Animal', expected: 'IDKEYANIMALS'},
  91             {keyLabel: 'Creature', expected: 'IDKEYANIMALS'},
  92             // Non-existent label returns empty string
  93             {keyLabel: 'ThisKeyLabelDoesntExist', expected: ''},
  94         ]
  95         testCases.forEach(tc => {
  96             const tagValueID = Vocabulary.getTagKeyID(tc.keyLabel, vocabulary);
  97             expect(tagValueID).toEqual(tc.expected);
  98         });
  99     });
 100
 101     it('returns an key label for a given key id', () => {
 102         const testCases = [
 103             // ID with many labels return the first one
 104             {keyID: 'IDKEYANIMALS', expected: 'Animal'},
 105             // Key IDs without any labels or unknown keys should return the literal
 106             // key from the API's response (that is, the key 'id')
 107             {keyID: 'IDKEYCOMMENT', expected: 'IDKEYCOMMENT'},
 108             {keyID: 'FOO', expected: 'FOO'},
 109         ]
 110         testCases.forEach(tc => {
 111             const tagValueID = Vocabulary.getTagKeyLabel(tc.keyID, vocabulary);
 112             expect(tagValueID).toEqual(tc.expected);
 113         });
 114     });
 115
 116     it('returns a value id for a given key id and value label', () => {
 117         const testCases = [
 118             // Key ID and value label known
 119             {keyID: 'IDKEYANIMALS', valueLabel: 'Human', expected: 'IDVALANIMALS1'},
 120             {keyID: 'IDKEYANIMALS', valueLabel: 'Homo sapiens', expected: 'IDVALANIMALS1'},
 121             // Key ID known, value label unknown
 122             {keyID: 'IDKEYANIMALS', valueLabel: 'Dinosaur', expected: ''},
 123             // Key ID unknown
 124             {keyID: 'IDNONSENSE', valueLabel: 'Does not matter', expected: ''},
 125         ]
 126         testCases.forEach(tc => {
 127             const tagValueID = Vocabulary.getTagValueID(tc.keyID, tc.valueLabel, vocabulary);
 128             expect(tagValueID).toEqual(tc.expected);
 129         });
 130     });
 131
 132     it('returns a value label for a given key & value id pair', () => {
 133         const testCases = [
 134             // Known key & value ids with multiple value labels: returns the first label
 135             {keyId: 'IDKEYANIMALS', valueId: 'IDVALANIMALS1', expected: 'Human'},
 136             // Values without label or unknown values should return the literal value from
 137             // the API's response (that is, the value 'id')
 138             {keyId: 'IDKEYSIZES', valueId: 'IDVALSIZES4', expected: 'IDVALSIZES4'},
 139             {keyId: 'IDKEYCOMMENT', valueId: 'FOO', expected: 'FOO'},
 140             {keyId: 'IDKEYANIMALS', valueId: 'BAR', expected: 'BAR'},
 141             {keyId: 'IDKEYNONSENSE', valueId: 'FOOBAR', expected: 'FOOBAR'},
 142         ]
 143         testCases.forEach(tc => {
 144             const tagValueLabel = Vocabulary.getTagValueLabel(tc.keyId, tc.valueId, vocabulary);
 145             expect(tagValueLabel).toEqual(tc.expected);
 146         });
 147     });
 148 });