← Back to branch summary

~rvb/maas/transaction-1.7-bug-1409852

« back to all changes in this revision

Viewing changes to src/maasserver/api/tests/test_tag.py

merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/api/tests/test_tag.py
44
44
        return reverse('tag_handler', args=[tag.name])
45
45
 
46
46
    def test_DELETE_requires_admin(self):
47
 
        tag = factory.make_tag()
 
47
        tag = factory.make_Tag()
48
48
        response = self.client.delete(self.get_tag_uri(tag))
49
49
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
50
50
        self.assertItemsEqual([tag], Tag.objects.filter(id=tag.id))
51
51
 
52
52
    def test_DELETE_removes_tag(self):
53
53
        self.become_admin()
54
 
        tag = factory.make_tag()
 
54
        tag = factory.make_Tag()
55
55
        response = self.client.delete(self.get_tag_uri(tag))
56
56
        self.assertEqual(httplib.NO_CONTENT, response.status_code)
57
57
        self.assertFalse(Tag.objects.filter(id=tag.id).exists())
64
64
 
65
65
    def test_GET_returns_tag(self):
66
66
        # The api allows for fetching a single Node (using system_id).
67
 
        tag = factory.make_tag('tag-name')
 
67
        tag = factory.make_Tag('tag-name')
68
68
        url = reverse('tag_handler', args=['tag-name'])
69
69
        response = self.client.get(url)
70
70
 
82
82
        self.assertEqual(httplib.NOT_FOUND, response.status_code)
83
83
 
84
84
    def test_PUT_refuses_non_superuser(self):
85
 
        tag = factory.make_tag()
 
85
        tag = factory.make_Tag()
86
86
        response = self.client_put(
87
87
            self.get_tag_uri(tag), {'comment': 'A special comment'})
88
88
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
89
89
 
90
90
    def test_PUT_updates_tag(self):
91
91
        self.become_admin()
92
 
        tag = factory.make_tag()
 
92
        tag = factory.make_Tag()
93
93
        # Note that 'definition' is not being sent
94
94
        response = self.client_put(
95
95
            self.get_tag_uri(tag),
104
104
        self.assertTrue(Tag.objects.filter(name='new-tag-name').exists())
105
105
 
106
106
    def test_PUT_updates_node_associations(self):
107
 
        node1 = factory.make_node()
 
107
        node1 = factory.make_Node()
108
108
        inject_lshw_result(node1, b'<node><foo/></node>')
109
 
        node2 = factory.make_node()
 
109
        node2 = factory.make_Node()
110
110
        inject_lshw_result(node2, b'<node><bar/></node>')
111
 
        tag = factory.make_tag(definition='//node/foo')
 
111
        tag = factory.make_Tag(definition='//node/foo')
112
112
        self.assertItemsEqual([tag.name], node1.tag_names())
113
113
        self.assertItemsEqual([], node2.tag_names())
114
114
        self.become_admin()
120
120
        self.assertItemsEqual([tag.name], node2.tag_names())
121
121
 
122
122
    def test_GET_nodes_with_no_nodes(self):
123
 
        tag = factory.make_tag()
 
123
        tag = factory.make_Tag()
124
124
        response = self.client.get(self.get_tag_uri(tag), {'op': 'nodes'})
125
125
 
126
126
        self.assertEqual(httplib.OK, response.status_code)
128
128
        self.assertEqual([], parsed_result)
129
129
 
130
130
    def test_GET_nodes_returns_nodes(self):
131
 
        tag = factory.make_tag()
132
 
        node1 = factory.make_node()
 
131
        tag = factory.make_Tag()
 
132
        node1 = factory.make_Node()
133
133
        # Create a second node that isn't tagged.
134
 
        factory.make_node()
 
134
        factory.make_Node()
135
135
        node1.tags.add(tag)
136
136
        response = self.client.get(self.get_tag_uri(tag), {'op': 'nodes'})
137
137
 
141
141
                         [r['system_id'] for r in parsed_result])
142
142
 
143
143
    def test_GET_nodes_hides_invisible_nodes(self):
144
 
        user2 = factory.make_user()
145
 
        node1 = factory.make_node()
 
144
        user2 = factory.make_User()
 
145
        node1 = factory.make_Node()
146
146
        inject_lshw_result(node1, b'<node><foo/></node>')
147
 
        node2 = factory.make_node(status=NODE_STATUS.ALLOCATED, owner=user2)
 
147
        node2 = factory.make_Node(status=NODE_STATUS.ALLOCATED, owner=user2)
148
148
        inject_lshw_result(node2, b'<node><bar/></node>')
149
 
        tag = factory.make_tag(definition='//node')
 
149
        tag = factory.make_Tag(definition='//node')
150
150
        response = self.client.get(self.get_tag_uri(tag), {'op': 'nodes'})
151
151
 
152
152
        self.assertEqual(httplib.OK, response.status_code)
163
163
 
164
164
    def test_PUT_invalid_definition(self):
165
165
        self.become_admin()
166
 
        node = factory.make_node()
 
166
        node = factory.make_Node()
167
167
        inject_lshw_result(node, b'<node ><child/></node>')
168
 
        tag = factory.make_tag(definition='//child')
 
168
        tag = factory.make_Tag(definition='//child')
169
169
        self.assertItemsEqual([tag.name], node.tag_names())
170
170
        response = self.client_put(
171
171
            self.get_tag_uri(tag), {'definition': 'invalid::tag'})
185
185
        self.assertEqual(httplib.NOT_FOUND, response.status_code)
186
186
 
187
187
    def test_POST_update_nodes_changes_associations(self):
188
 
        tag = factory.make_tag()
 
188
        tag = factory.make_Tag()
189
189
        self.become_admin()
190
 
        node_first = factory.make_node()
191
 
        node_second = factory.make_node()
 
190
        node_first = factory.make_Node()
 
191
        node_second = factory.make_Node()
192
192
        node_first.tags.add(tag)
193
193
        self.assertItemsEqual([node_first], tag.node_set.all())
194
194
        response = self.client.post(
203
203
        self.assertEqual({'added': 1, 'removed': 1}, parsed_result)
204
204
 
205
205
    def test_POST_update_nodes_ignores_unknown_nodes(self):
206
 
        tag = factory.make_tag()
 
206
        tag = factory.make_Tag()
207
207
        self.become_admin()
208
208
        unknown_add_system_id = generate_node_system_id()
209
209
        unknown_remove_system_id = generate_node_system_id()
220
220
        self.assertEqual({'added': 0, 'removed': 0}, parsed_result)
221
221
 
222
222
    def test_POST_update_nodes_doesnt_require_add_or_remove(self):
223
 
        tag = factory.make_tag()
224
 
        node = factory.make_node()
 
223
        tag = factory.make_Tag()
 
224
        node = factory.make_Node()
225
225
        self.become_admin()
226
226
        self.assertItemsEqual([], tag.node_set.all())
227
227
        response = self.client.post(
242
242
        self.assertEqual({'added': 0, 'removed': 1}, parsed_result)
243
243
 
244
244
    def test_POST_update_nodes_rejects_normal_user(self):
245
 
        tag = factory.make_tag()
246
 
        node = factory.make_node()
 
245
        tag = factory.make_Tag()
 
246
        node = factory.make_Node()
247
247
        response = self.client.post(
248
248
            self.get_tag_uri(tag), {
249
249
                'op': 'update_nodes',
253
253
        self.assertItemsEqual([], tag.node_set.all())
254
254
 
255
255
    def test_POST_update_nodes_allows_nodegroup_worker(self):
256
 
        tag = factory.make_tag()
257
 
        nodegroup = factory.make_node_group()
258
 
        node = factory.make_node(nodegroup=nodegroup)
 
256
        tag = factory.make_Tag()
 
257
        nodegroup = factory.make_NodeGroup()
 
258
        node = factory.make_Node(nodegroup=nodegroup)
259
259
        client = make_worker_client(nodegroup)
260
260
        response = client.post(
261
261
            self.get_tag_uri(tag), {
269
269
        self.assertItemsEqual([node], tag.node_set.all())
270
270
 
271
271
    def test_POST_update_nodes_refuses_unidentified_nodegroup_worker(self):
272
 
        tag = factory.make_tag()
273
 
        nodegroup = factory.make_node_group()
274
 
        node = factory.make_node(nodegroup=nodegroup)
 
272
        tag = factory.make_Tag()
 
273
        nodegroup = factory.make_NodeGroup()
 
274
        node = factory.make_Node(nodegroup=nodegroup)
275
275
        client = make_worker_client(nodegroup)
276
276
        # We don't pass nodegroup:uuid so we get refused
277
277
        response = client.post(
283
283
        self.assertItemsEqual([], tag.node_set.all())
284
284
 
285
285
    def test_POST_update_nodes_refuses_non_nodegroup_worker(self):
286
 
        tag = factory.make_tag()
287
 
        nodegroup = factory.make_node_group()
288
 
        node = factory.make_node(nodegroup=nodegroup)
 
286
        tag = factory.make_Tag()
 
287
        nodegroup = factory.make_NodeGroup()
 
288
        node = factory.make_Node(nodegroup=nodegroup)
289
289
        response = self.client.post(
290
290
            self.get_tag_uri(tag), {
291
291
                'op': 'update_nodes',
296
296
        self.assertItemsEqual([], tag.node_set.all())
297
297
 
298
298
    def test_POST_update_nodes_doesnt_modify_other_nodegroup_nodes(self):
299
 
        tag = factory.make_tag()
300
 
        nodegroup_mine = factory.make_node_group()
301
 
        nodegroup_theirs = factory.make_node_group()
302
 
        node_theirs = factory.make_node(nodegroup=nodegroup_theirs)
 
299
        tag = factory.make_Tag()
 
300
        nodegroup_mine = factory.make_NodeGroup()
 
301
        nodegroup_theirs = factory.make_NodeGroup()
 
302
        node_theirs = factory.make_Node(nodegroup=nodegroup_theirs)
303
303
        client = make_worker_client(nodegroup_mine)
304
304
        response = client.post(
305
305
            self.get_tag_uri(tag), {
313
313
        self.assertItemsEqual([], tag.node_set.all())
314
314
 
315
315
    def test_POST_update_nodes_ignores_incorrect_definition(self):
316
 
        tag = factory.make_tag()
 
316
        tag = factory.make_Tag()
317
317
        orig_def = tag.definition
318
 
        nodegroup = factory.make_node_group()
319
 
        node = factory.make_node(nodegroup=nodegroup)
 
318
        nodegroup = factory.make_NodeGroup()
 
319
        node = factory.make_Node(nodegroup=nodegroup)
320
320
        client = make_worker_client(nodegroup)
321
321
        tag.definition = '//new/node/definition'
322
322
        tag.save()
332
332
        self.assertItemsEqual([], node.tags.all())
333
333
 
334
334
    def test_POST_rebuild_rebuilds_node_mapping(self):
335
 
        tag = factory.make_tag(definition='//foo/bar')
 
335
        tag = factory.make_Tag(definition='//foo/bar')
336
336
        # Only one node matches the tag definition, rebuilding should notice
337
 
        node_matching = factory.make_node()
 
337
        node_matching = factory.make_Node()
338
338
        inject_lshw_result(node_matching, b'<foo><bar/></foo>')
339
 
        node_bogus = factory.make_node()
 
339
        node_bogus = factory.make_Node()
340
340
        inject_lshw_result(node_bogus, b'<foo/>')
341
341
        node_matching.tags.add(tag)
342
342
        node_bogus.tags.add(tag)
350
350
        self.assertItemsEqual([node_matching], tag.node_set.all())
351
351
 
352
352
    def test_POST_rebuild_leaves_manual_tags(self):
353
 
        tag = factory.make_tag(definition='')
354
 
        node = factory.make_node()
 
353
        tag = factory.make_Tag(definition='')
 
354
        node = factory.make_Node()
355
355
        node.tags.add(tag)
356
356
        self.assertItemsEqual([node], tag.node_set.all())
357
357
        self.become_admin()
369
369
        self.assertEqual(httplib.NOT_FOUND, response.status_code)
370
370
 
371
371
    def test_POST_rebuild_requires_admin(self):
372
 
        tag = factory.make_tag(definition='/foo/bar')
 
372
        tag = factory.make_Tag(definition='/foo/bar')
373
373
        response = self.client.post(
374
374
            self.get_tag_uri(tag), {'op': 'rebuild'})
375
375
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
484
484
 
485
485
    def test_POST_new_populates_nodes(self):
486
486
        self.become_admin()
487
 
        node1 = factory.make_node()
 
487
        node1 = factory.make_Node()
488
488
        inject_lshw_result(node1, b'<node><child/></node>')
489
489
        # Create another node that doesn't have a 'child'
490
 
        node2 = factory.make_node()
 
490
        node2 = factory.make_Node()
491
491
        inject_lshw_result(node2, b'<node/>')
492
492
        self.assertItemsEqual([], node1.tag_names())
493
493
        self.assertItemsEqual([], node2.tag_names())