18574: Adds some more test cases on convert_to_* methods.
[arvados.git] / 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'})