sdk/python/tests/test_vocabulary.py

   1 # Copyright (C) The Arvados Authors. All rights reserved.
   2 #
   3 # SPDX-License-Identifier: Apache-2.0
   4
   5 import arvados
   6 import unittest
   7 import mock
   8
   9 from arvados import api, vocabulary
  10
  11 class VocabularyTest(unittest.TestCase):
  12     EXAMPLE_VOC = {
  13         'tags': {
  14             'IDTAGANIMALS': {
  15                 'strict': False,
  16                 'labels': [
  17                     {'label': 'Animal'},
  18                     {'label': 'Creature'},
  19                 ],
  20                 'values': {
  21                     'IDVALANIMAL1': {
  22                         'labels': [
  23                             {'label': 'Human'},
  24                             {'label': 'Homo sapiens'},
  25                         ],
  26                     },
  27                     'IDVALANIMAL2': {
  28                         'labels': [
  29                             {'label': 'Elephant'},
  30                             {'label': 'Loxodonta'},
  31                         ],
  32                     },
  33                 },
  34             },
  35             'IDTAGIMPORTANCES': {
  36                 'strict': True,
  37                 'labels': [
  38                     {'label': 'Importance'},
  39                     {'label': 'Priority'},
  40                 ],
  41                 'values': {
  42                     'IDVALIMPORTANCE1': {
  43                         'labels': [
  44                             {'label': 'High'},
  45                             {'label': 'High priority'},
  46                         ],
  47                     },
  48                     'IDVALIMPORTANCE2': {
  49                         'labels': [
  50                             {'label': 'Medium'},
  51                             {'label': 'Medium priority'},
  52                         ],
  53                     },
  54                     'IDVALIMPORTANCE3': {
  55                         'labels': [
  56                             {'label': 'Low'},
  57                             {'label': 'Low priority'},
  58                         ],
  59                     },
  60                 },
  61             },
  62             'IDTAGCOMMENTS': {
  63                 'strict': False,
  64                 'labels': [
  65                     {'label': 'Comment'},
  66                     {'label': 'Notes'},
  67                 ],
  68             },
  69         },
  70     }
  71
  72     def setUp(self):
  73         self.api = arvados.api('v1')
  74         self.voc = vocabulary.Vocabulary(self.EXAMPLE_VOC)
  75         self.api.vocabulary = mock.MagicMock(return_value=self.EXAMPLE_VOC)
  76
  77     def test_vocabulary_keys(self):
  78         self.assertEqual(self.voc.strict_keys, False)
  79         self.assertEqual(
  80             self.voc.key_aliases.keys(),
  81             set(['idtaganimals', 'creature', 'animal',
  82                 'idtagimportances', 'importance', 'priority',
  83                 'idtagcomments', 'comment', 'notes'])
  84         )
  85
  86         vk = self.voc.key_aliases['creature']
  87         self.assertEqual(vk.strict, False)
  88         self.assertEqual(vk.identifier, 'IDTAGANIMALS')
  89         self.assertEqual(vk.aliases, ['Animal', 'Creature'])
  90         self.assertEqual(vk.preferred_label, 'Animal')
  91         self.assertEqual(
  92             vk.value_aliases.keys(),
  93             set(['idvalanimal1', 'human', 'homo sapiens',
  94                 'idvalanimal2', 'elephant', 'loxodonta'])
  95         )
  96
  97     def test_vocabulary_values(self):
  98         vk = self.voc.key_aliases['creature']
  99         vv = vk.value_aliases['human']
 100         self.assertEqual(vv.identifier, 'IDVALANIMAL1')
 101         self.assertEqual(vv.aliases, ['Human', 'Homo sapiens'])
 102         self.assertEqual(vv.preferred_label, 'Human')
 103
 104     def test_vocabulary_indexing(self):
 105         self.assertEqual(self.voc['creature']['human'].identifier, 'IDVALANIMAL1')
 106         self.assertEqual(self.voc['Creature']['Human'].identifier, 'IDVALANIMAL1')
 107         self.assertEqual(self.voc['CREATURE']['HUMAN'].identifier, 'IDVALANIMAL1')
 108         with self.assertRaises(KeyError):
 109             inexistant = self.voc['foo']
 110
 111     def test_empty_vocabulary(self):
 112         voc = vocabulary.Vocabulary({})
 113         self.assertEqual(voc.strict_keys, False)
 114         self.assertEqual(voc.key_aliases, {})
 115
 116     def test_load_vocabulary_with_api(self):
 117         voc = vocabulary.load_vocabulary(self.api)
 118         self.assertEqual(voc['creature']['human'].identifier, 'IDVALANIMAL1')
 119         self.assertEqual(voc['Creature']['Human'].identifier, 'IDVALANIMAL1')
 120         self.assertEqual(voc['CREATURE']['HUMAN'].identifier, 'IDVALANIMAL1')
 121
 122     def test_convert_to_identifiers(self):
 123         cases = [
 124             {'IDTAGIMPORTANCES': 'IDVALIMPORTANCE1'},
 125             {'IDTAGIMPORTANCES': 'High'},
 126             {'importance': 'IDVALIMPORTANCE1'},
 127             {'priority': 'high priority'},
 128         ]
 129         for case in cases:
 130             self.assertEqual(
 131                 self.voc.convert_to_identifiers(case),
 132                 {'IDTAGIMPORTANCES': 'IDVALIMPORTANCE1'},
 133                 "failing test case: {}".format(case)
 134             )
 135
 136     def test_convert_to_identifiers_multiple_pairs(self):
 137         cases = [
 138             {'IDTAGIMPORTANCES': 'IDVALIMPORTANCE1', 'IDTAGANIMALS': 'IDVALANIMAL1', 'IDTAGCOMMENTS': 'Very important person'},
 139             {'IDTAGIMPORTANCES': 'High', 'IDTAGANIMALS': 'IDVALANIMAL1', 'comment': 'Very important person'},
 140             {'importance': 'IDVALIMPORTANCE1', 'animal': 'IDVALANIMAL1', 'notes': 'Very important person'},
 141             {'priority': 'high priority', 'animal': 'IDVALANIMAL1', 'NOTES': 'Very important person'},
 142         ]
 143         for case in cases:
 144             self.assertEqual(
 145                 self.voc.convert_to_identifiers(case),
 146                 {'IDTAGIMPORTANCES': 'IDVALIMPORTANCE1', 'IDTAGANIMALS': 'IDVALANIMAL1', 'IDTAGCOMMENTS': 'Very important person'},
 147                 "failing test case: {}".format(case)
 148             )
 149
 150     def test_convert_to_identifiers_unknown_key(self):
 151         # Non-strict vocabulary
 152         self.assertEqual(self.voc.strict_keys, False)
 153         self.assertEqual(self.voc.convert_to_identifiers({'foo': 'bar'}), {'foo': 'bar'})
 154         # Strict vocabulary
 155         strict_voc = arvados.vocabulary.Vocabulary(self.EXAMPLE_VOC)
 156         strict_voc.strict_keys = True
 157         with self.assertRaises(KeyError):
 158             strict_voc.convert_to_identifiers({'foo': 'bar'})
 159
 160     def test_convert_to_identifiers_unknown_value(self):
 161         # Non-strict key
 162         self.assertEqual(self.voc['animal'].strict, False)
 163         self.assertEqual(self.voc.convert_to_identifiers({'Animal': 'foo'}), {'IDTAGANIMALS': 'foo'})
 164         # Strict key
 165         self.assertEqual(self.voc['priority'].strict, True)
 166         with self.assertRaises(ValueError):
 167             self.voc.convert_to_identifiers({'Priority': 'foo'})
 168
 169     def test_convert_to_labels(self):
 170         cases = [
 171             {'IDTAGIMPORTANCES': 'IDVALIMPORTANCE1'},
 172             {'IDTAGIMPORTANCES': 'High'},
 173             {'importance': 'IDVALIMPORTANCE1'},
 174             {'priority': 'high priority'},
 175         ]
 176         for case in cases:
 177             self.assertEqual(
 178                 self.voc.convert_to_labels(case),
 179                 {'Importance': 'High'},
 180                 "failing test case: {}".format(case)
 181             )
 182
 183     def test_convert_to_labels_multiple_pairs(self):
 184         cases = [
 185             {'IDTAGIMPORTANCES': 'IDVALIMPORTANCE1', 'IDTAGANIMALS': 'IDVALANIMAL1', 'IDTAGCOMMENTS': 'Very important person'},
 186             {'IDTAGIMPORTANCES': 'High', 'IDTAGANIMALS': 'IDVALANIMAL1', 'comment': 'Very important person'},
 187             {'importance': 'IDVALIMPORTANCE1', 'animal': 'IDVALANIMAL1', 'notes': 'Very important person'},
 188             {'priority': 'high priority', 'animal': 'IDVALANIMAL1', 'NOTES': 'Very important person'},
 189         ]
 190         for case in cases:
 191             self.assertEqual(
 192                 self.voc.convert_to_labels(case),
 193                 {'Importance': 'High', 'Animal': 'Human', 'Comment': 'Very important person'},
 194                 "failing test case: {}".format(case)
 195             )
 196
 197     def test_convert_roundtrip(self):
 198         initial = {'IDTAGIMPORTANCES': 'IDVALIMPORTANCE1', 'IDTAGANIMALS': 'IDVALANIMAL1', 'IDTAGCOMMENTS': 'Very important person'}
 199         converted = self.voc.convert_to_labels(initial)
 200         self.assertNotEqual(converted, initial)
 201         self.assertEqual(self.voc.convert_to_identifiers(converted), initial)
 202
 203     def test_convert_to_labels_unknown_key(self):
 204         # Non-strict vocabulary
 205         self.assertEqual(self.voc.strict_keys, False)
 206         self.assertEqual(self.voc.convert_to_labels({'foo': 'bar'}), {'foo': 'bar'})
 207         # Strict vocabulary
 208         strict_voc = arvados.vocabulary.Vocabulary(self.EXAMPLE_VOC)
 209         strict_voc.strict_keys = True
 210         with self.assertRaises(KeyError):
 211             strict_voc.convert_to_labels({'foo': 'bar'})
 212
 213     def test_convert_to_labels_unknown_value(self):
 214         # Non-strict key
 215         self.assertEqual(self.voc['animal'].strict, False)
 216         self.assertEqual(self.voc.convert_to_labels({'IDTAGANIMALS': 'foo'}), {'Animal': 'foo'})
 217         # Strict key
 218         self.assertEqual(self.voc['priority'].strict, True)
 219         with self.assertRaises(ValueError):
 220             self.voc.convert_to_labels({'IDTAGIMPORTANCES': 'foo'})