← 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_network.py

merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/api/tests/test_network.py
35
35
 
36
36
    def test_POST_is_prohibited(self):
37
37
        self.become_admin()
38
 
        network = factory.make_network()
 
38
        network = factory.make_Network()
39
39
        response = self.client.post(
40
40
            self.get_url(network.name),
41
41
            {'description': "New description"})
42
42
        self.assertEqual(httplib.BAD_REQUEST, response.status_code)
43
43
 
44
44
    def test_GET_returns_network(self):
45
 
        network = factory.make_network()
 
45
        network = factory.make_Network()
46
46
 
47
47
        response = self.client.get(self.get_url(network.name))
48
48
        self.assertEqual(httplib.OK, response.status_code)
55
55
                network.netmask,
56
56
                network.vlan_tag,
57
57
                network.description,
 
58
                network.default_gateway,
 
59
                network.dns_servers,
58
60
            ),
59
61
            (
60
62
                parsed_result['name'],
62
64
                parsed_result['netmask'],
63
65
                parsed_result['vlan_tag'],
64
66
                parsed_result['description'],
 
67
                parsed_result['default_gateway'],
 
68
                parsed_result['dns_servers'],
65
69
            ))
66
70
 
67
71
    def test_GET_returns_404_for_unknown_network(self):
71
75
 
72
76
    def test_PUT_updates_network(self):
73
77
        self.become_admin()
74
 
        network = factory.make_network()
 
78
        network = factory.make_Network()
75
79
        new_net = factory.getRandomNetwork()
76
80
        new_values = {
77
81
            'name': factory.make_name('new'),
79
83
            'netmask': '%s' % new_net.netmask,
80
84
            'vlan_tag': factory.make_vlan_tag(),
81
85
            'description': "Changed description",
 
86
            'default_gateway': factory.getRandomIPAddress(),
 
87
            'dns_servers': factory.getRandomIPAddress(),
82
88
            }
83
89
 
84
90
        response = self.client_put(self.get_url(network.name), new_values)
89
95
 
90
96
    def test_PUT_requires_admin(self):
91
97
        description = "Original description"
92
 
        network = factory.make_network(description=description)
 
98
        network = factory.make_Network(description=description)
93
99
        response = self.client_put(
94
100
            self.get_url(network.name), {'description': "Changed description"})
95
101
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
103
109
 
104
110
    def test_DELETE_deletes_network(self):
105
111
        self.become_admin()
106
 
        network = factory.make_network()
 
112
        network = factory.make_Network()
107
113
        response = self.client.delete(self.get_url(network.name))
108
114
        self.assertEqual(httplib.NO_CONTENT, response.status_code)
109
115
        self.assertIsNone(reload_object(network))
110
116
 
111
117
    def test_DELETE_requires_admin(self):
112
 
        network = factory.make_network()
 
118
        network = factory.make_Network()
113
119
        response = self.client.delete(self.get_url(network.name))
114
120
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
115
121
        self.assertIsNotNone(reload_object(network))
123
129
 
124
130
    def test_DELETE_works_with_MACs_attached(self):
125
131
        self.become_admin()
126
 
        network = factory.make_network()
127
 
        mac = factory.make_mac_address(networks=[network])
 
132
        network = factory.make_Network()
 
133
        mac = factory.make_MACAddress(networks=[network])
128
134
        response = self.client.delete(self.get_url(network.name))
129
135
        self.assertEqual(httplib.NO_CONTENT, response.status_code)
130
136
        self.assertIsNone(reload_object(network))
133
139
 
134
140
    def test_POST_connect_macs_connects_macs_to_network(self):
135
141
        self.become_admin()
136
 
        network = factory.make_network()
137
 
        macs = [factory.make_mac_address(networks=[network]) for _ in range(2)]
 
142
        network = factory.make_Network()
 
143
        macs = [factory.make_MACAddress(networks=[network]) for _ in range(2)]
138
144
        response = self.client.post(
139
145
            self.get_url(network.name),
140
146
            {
146
152
 
147
153
    def test_POST_connect_macs_accepts_empty_macs_list(self):
148
154
        self.become_admin()
149
 
        network = factory.make_network()
 
155
        network = factory.make_Network()
150
156
        response = self.client.post(
151
157
            self.get_url(network.name),
152
158
            {
158
164
 
159
165
    def test_POST_connect_macs_leaves_other_networks_unchanged(self):
160
166
        self.become_admin()
161
 
        network = factory.make_network()
162
 
        other_network = factory.make_network()
163
 
        mac = factory.make_mac_address(networks=[other_network])
 
167
        network = factory.make_Network()
 
168
        other_network = factory.make_Network()
 
169
        mac = factory.make_MACAddress(networks=[other_network])
164
170
        response = self.client.post(
165
171
            self.get_url(network.name),
166
172
            {
172
178
 
173
179
    def test_POST_connect_macs_leaves_other_MACs_unchanged(self):
174
180
        self.become_admin()
175
 
        network = factory.make_network()
176
 
        mac = factory.make_mac_address(networks=[])
177
 
        other_mac = factory.make_mac_address(networks=[network])
 
181
        network = factory.make_Network()
 
182
        mac = factory.make_MACAddress(networks=[])
 
183
        other_mac = factory.make_MACAddress(networks=[network])
178
184
        response = self.client.post(
179
185
            self.get_url(network.name),
180
186
            {
186
192
 
187
193
    def test_POST_connect_macs_ignores_MACs_already_on_network(self):
188
194
        self.become_admin()
189
 
        network = factory.make_network()
190
 
        mac = factory.make_mac_address(networks=[network])
 
195
        network = factory.make_Network()
 
196
        mac = factory.make_MACAddress(networks=[network])
191
197
        response = self.client.post(
192
198
            self.get_url(network.name),
193
199
            {
198
204
        self.assertEqual({mac}, set(network.macaddress_set.all()))
199
205
 
200
206
    def test_POST_connect_macs_requires_admin(self):
201
 
        network = factory.make_network()
 
207
        network = factory.make_Network()
202
208
        response = self.client.post(
203
209
            self.get_url(network.name),
204
210
            {
209
215
 
210
216
    def test_POST_connect_macs_fails_on_unknown_MAC(self):
211
217
        self.become_admin()
212
 
        network = factory.make_network()
 
218
        network = factory.make_Network()
213
219
        nonexistent_mac = factory.make_MAC()
214
220
        response = self.client.post(
215
221
            self.get_url(network.name),
224
230
 
225
231
    def test_POST_disconnect_macs_removes_MACs_from_network(self):
226
232
        self.become_admin()
227
 
        network = factory.make_network()
228
 
        mac = factory.make_mac_address(networks=[network])
 
233
        network = factory.make_Network()
 
234
        mac = factory.make_MACAddress(networks=[network])
229
235
        response = self.client.post(
230
236
            self.get_url(network.name),
231
237
            {
237
243
 
238
244
    def test_POST_disconnect_macs_requires_admin(self):
239
245
        response = self.client.post(
240
 
            self.get_url(factory.make_network().name),
 
246
            self.get_url(factory.make_Network().name),
241
247
            {
242
248
                'op': 'disconnect_macs',
243
 
                'macs': [factory.make_mac_address().mac_address],
 
249
                'macs': [factory.make_MACAddress().mac_address],
244
250
            })
245
251
        self.assertEqual(httplib.FORBIDDEN, response.status_code)
246
252
 
247
253
    def test_POST_disconnect_macs_accepts_empty_MACs_list(self):
248
254
        self.become_admin()
249
255
        response = self.client.post(
250
 
            self.get_url(factory.make_network().name),
 
256
            self.get_url(factory.make_Network().name),
251
257
            {
252
258
                'op': 'disconnect_macs',
253
259
                'macs': [],
257
263
    def test_POST_disconnect_macs_is_idempotent(self):
258
264
        self.become_admin()
259
265
        response = self.client.post(
260
 
            self.get_url(factory.make_network().name),
 
266
            self.get_url(factory.make_Network().name),
261
267
            {
262
268
                'op': 'disconnect_macs',
263
 
                'macs': [factory.make_mac_address().mac_address],
 
269
                'macs': [factory.make_MACAddress().mac_address],
264
270
            })
265
271
        self.assertEqual(httplib.OK, response.status_code)
266
272
 
267
273
    def test_POST_disconnect_macs_leaves_other_MACs_unchanged(self):
268
274
        self.become_admin()
269
 
        network = factory.make_network()
270
 
        other_mac = factory.make_mac_address(networks=[network])
 
275
        network = factory.make_Network()
 
276
        other_mac = factory.make_MACAddress(networks=[network])
271
277
        response = self.client.post(
272
278
            self.get_url(network.name),
273
279
            {
274
280
                'op': 'disconnect_macs',
275
281
                'macs': [
276
 
                    factory.make_mac_address(networks=[network]).mac_address
 
282
                    factory.make_MACAddress(networks=[network]).mac_address
277
283
                    ],
278
284
            })
279
285
        self.assertEqual(httplib.OK, response.status_code)
281
287
 
282
288
    def test_POST_disconnect_macs_leaves_other_networks_unchanged(self):
283
289
        self.become_admin()
284
 
        network = factory.make_network()
285
 
        other_network = factory.make_network()
286
 
        mac = factory.make_mac_address(networks=[network, other_network])
 
290
        network = factory.make_Network()
 
291
        other_network = factory.make_Network()
 
292
        mac = factory.make_MACAddress(networks=[network, other_network])
287
293
        response = self.client.post(
288
294
            self.get_url(network.name),
289
295
            {
297
303
        self.become_admin()
298
304
        nonexistent_mac = factory.make_MAC()
299
305
        response = self.client.post(
300
 
            self.get_url(factory.make_network().name),
 
306
            self.get_url(factory.make_Network().name),
301
307
            {
302
308
                'op': 'disconnect_macs',
303
309
                'macs': [nonexistent_mac],
326
332
        if networks is None:
327
333
            networks = []
328
334
        if owner is None:
329
 
            owner = factory.make_user()
 
335
            owner = factory.make_User()
330
336
        if node is None:
331
 
            node = factory.make_node(status=NODE_STATUS.ALLOCATED, owner=owner)
332
 
        return factory.make_mac_address(networks=networks, node=node)
 
337
            node = factory.make_Node(status=NODE_STATUS.ALLOCATED, owner=owner)
 
338
        return factory.make_MACAddress(networks=networks, node=node)
333
339
 
334
340
    def request_connected_macs(self, network):
335
341
        """Request and return the MAC addresses attached to `network`."""
343
349
        return [item['mac_address'] for item in returned_macs]
344
350
 
345
351
    def test_returns_connected_macs(self):
346
 
        network = factory.make_network()
 
352
        network = factory.make_Network()
347
353
        macs = [
348
354
            self.make_mac(networks=[network], owner=self.logged_in_user)
349
355
            for _ in range(3)
354
360
 
355
361
    def test_ignores_unconnected_macs(self):
356
362
        self.make_mac(
357
 
            networks=[factory.make_network()], owner=self.logged_in_user)
 
363
            networks=[factory.make_Network()], owner=self.logged_in_user)
358
364
        self.make_mac(networks=[], owner=self.logged_in_user)
359
365
        self.assertEqual(
360
366
            [],
361
 
            self.request_connected_macs(factory.make_network()))
 
367
            self.request_connected_macs(factory.make_Network()))
362
368
 
363
369
    def test_includes_MACs_for_nodes_visible_to_user(self):
364
 
        network = factory.make_network()
 
370
        network = factory.make_Network()
365
371
        mac = self.make_mac(networks=[network], owner=self.logged_in_user)
366
372
        self.assertEqual(
367
373
            [mac.mac_address],
368
374
            self.extract_macs(self.request_connected_macs(network)))
369
375
 
370
376
    def test_excludes_MACs_for_nodes_not_visible_to_user(self):
371
 
        network = factory.make_network()
 
377
        network = factory.make_Network()
372
378
        self.make_mac(networks=[network])
373
379
        self.assertEqual([], self.request_connected_macs(network))
374
380
 
375
381
    def test_returns_sorted_MACs(self):
376
 
        network = factory.make_network()
 
382
        network = factory.make_Network()
377
383
        macs = [
378
384
            self.make_mac(
379
 
                networks=[network], node=factory.make_node(sortable_name=True),
 
385
                networks=[network], node=factory.make_Node(sortable_name=True),
380
386
                owner=self.logged_in_user)
381
387
            for _ in range(4)
382
388
            ]