← Back to branch summary

~ltrager/maas/lp1554636_2.0

« back to all changes in this revision

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

Merge Blake's branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/api/tests/test_devices.py
6
6
__all__ = []
7
7
 
8
8
import http.client
9
 
import json
10
9
import random
11
10
 
12
11
from django.core.urlresolvers import reverse
28
27
)
29
28
from maasserver.testing.factory import factory
30
29
from maasserver.testing.orm import reload_object
 
30
from maasserver.utils.converters import json_load_bytes
31
31
from testtools.matchers import (
32
32
    HasLength,
33
33
    Not,
55
55
            })
56
56
        self.assertEqual(
57
57
            http.client.OK, response.status_code, response.content)
58
 
        system_id = json.loads(response.content)['system_id']
 
58
        system_id = json_load_bytes(response.content)['system_id']
59
59
        device = Node.devices.get(system_id=system_id)
60
60
        self.assertEqual(hostname, device.hostname)
61
61
        self.assertIsNone(device.parent)
83
83
            })
84
84
        self.assertEqual(
85
85
            http.client.OK, response.status_code, response.content)
86
 
        system_id = json.loads(response.content)['system_id']
 
86
        system_id = json_load_bytes(response.content)['system_id']
87
87
        device = Node.devices.get(system_id=system_id)
88
88
        self.assertEqual(hostname, device.hostname)
89
89
        self.assertEqual(parent, device.parent)
97
97
                'hostname': factory.make_string(),
98
98
                'mac_addresses': ['aa:bb:cc:dd:ee:ff'],
99
99
            })
100
 
        parsed_result = json.loads(response.content)
 
100
        parsed_result = json_load_bytes(response.content)
101
101
        self.assertItemsEqual(
102
102
            [
103
103
                'hostname',
126
126
        factory.make_Node(
127
127
            status=NODE_STATUS.ALLOCATED, owner=self.logged_in_user)
128
128
        response = self.client.get(reverse('devices_handler'), {'op': 'list'})
129
 
        parsed_result = json.loads(response.content)
 
129
        parsed_result = json_load_bytes(response.content)
130
130
 
131
131
        self.assertEqual(http.client.OK, response.status_code)
132
132
        self.assertItemsEqual(
137
137
        factory.make_Node(
138
138
            status=NODE_STATUS.ALLOCATED, owner=self.logged_in_user)
139
139
        response = self.client.get(reverse('devices_handler'), {'op': 'list'})
140
 
        parsed_result = json.loads(response.content)
 
140
        parsed_result = json_load_bytes(response.content)
141
141
 
142
142
        self.assertEqual(http.client.OK, response.status_code)
143
143
        self.assertEqual(
154
154
            'op': 'list',
155
155
            'id': [matching_id],
156
156
        })
157
 
        parsed_result = json.loads(response.content)
 
157
        parsed_result = json_load_bytes(response.content)
158
158
        self.assertItemsEqual(
159
159
            [matching_id],
160
160
            [device.get('system_id') for device in parsed_result])
169
169
            'op': 'list',
170
170
            'mac_address': [matching_mac],
171
171
        })
172
 
        parsed_result = json.loads(response.content)
 
172
        parsed_result = json_load_bytes(response.content)
173
173
        self.assertItemsEqual(
174
174
            [matching_device.system_id],
175
175
            [device.get('system_id') for device in parsed_result])
177
177
    def test_list_returns_limited_fields(self):
178
178
        self.create_devices(owner=self.logged_in_user)
179
179
        response = self.client.get(reverse('devices_handler'), {'op': 'list'})
180
 
        parsed_result = json.loads(response.content)
 
180
        parsed_result = json_load_bytes(response.content)
181
181
        self.assertItemsEqual(
182
182
            [
183
183
                'hostname',
221
221
        response = self.client.get(get_device_uri(device))
222
222
        self.assertEqual(
223
223
            http.client.OK, response.status_code, response.content)
224
 
        parsed_device = json.loads(response.content)
 
224
        parsed_device = json_load_bytes(response.content)
225
225
        self.assertEqual(device.system_id, parsed_device["system_id"])
226
226
 
227
227
    def test_PUT_updates_device_hostname(self):
292
292
            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
293
293
        self.assertEqual(
294
294
            http.client.OK, response.status_code, response.content)
295
 
        parsed_device = json.loads(response.content)
 
295
        parsed_device = json_load_bytes(response.content)
296
296
        [returned_ip] = parsed_device["ip_addresses"]
297
297
        static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
298
298
        self.assertIsNotNone(static_ip)
323
323
            })
324
324
        self.assertEqual(
325
325
            http.client.OK, response.status_code, response.content)
326
 
        parsed_device = json.loads(response.content)
 
326
        parsed_device = json_load_bytes(response.content)
327
327
        [returned_ip] = parsed_device["ip_addresses"]
328
328
        [given_ip] = StaticIPAddress.objects.all()
329
329
        self.assertEqual(
349
349
            })
350
350
        self.assertEqual(
351
351
            http.client.OK, response.status_code, response.content)
352
 
        parsed_device = json.loads(response.content)
 
352
        parsed_device = json_load_bytes(response.content)
353
353
        [returned_ip] = parsed_device["ip_addresses"]
354
354
        [given_ip] = StaticIPAddress.objects.all()
355
355
        self.assertEqual(
373
373
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
374
374
        self.assertEqual(
375
375
            dict(requested_address=["Enter a valid IPv4 or IPv6 address."]),
376
 
            json.loads(response.content))
 
376
            json_load_bytes(response.content))
377
377
 
378
378
    def test_rejects_invalid_mac(self):
379
379
        mac_address = factory.make_name('bogus')
393
393
            dict(
394
394
                mac_address=[
395
395
                    "'%s' is not a valid MAC address." % mac_address]),
396
 
            json.loads(response.content))
 
396
            json_load_bytes(response.content))
397
397
 
398
398
    def test_rejects_unrelated_mac(self):
399
399
        # Create an other device.
434
434
            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
435
435
        self.assertEqual(
436
436
            http.client.OK, response.status_code, response.content)
437
 
        parsed_device = json.loads(response.content)
 
437
        parsed_device = json_load_bytes(response.content)
438
438
        self.expectThat(parsed_device["ip_addresses"], Not(HasLength(0)))
439
439
 
440
440
        response = self.client.post(
441
441
            get_device_uri(device), {'op': 'release_sticky_ip_address'})
442
442
        self.assertEqual(
443
443
            http.client.OK, response.status_code, response.content)
444
 
        parsed_device = json.loads(response.content)
 
444
        parsed_device = json_load_bytes(response.content)
445
445
        self.expectThat(parsed_device["ip_addresses"], HasLength(0))
446
446
 
447
447
    def test__rejects_invalid_ip(self):
458
458
            http.client.BAD_REQUEST, response.status_code, response.content)
459
459
        self.assertEqual(
460
460
            dict(address=["Enter a valid IPv4 or IPv6 address."]),
461
 
            json.loads(response.content))
 
461
            json_load_bytes(response.content))
462
462
 
463
463
    def test__rejects_empty_ip(self):
464
464
        device = factory.make_Node(
503
503
            get_device_uri(device), {'op': 'release_sticky_ip_address'})
504
504
        self.assertEqual(
505
505
            http.client.OK, response.status_code, response.content)
506
 
        parsed_device = json.loads(response.content)
 
506
        parsed_device = json_load_bytes(response.content)
507
507
        self.expectThat(parsed_device["ip_addresses"], HasLength(0))
508
508
 
509
509
    def test__releases_specific_address(self):
536
536
            })
537
537
        self.assertEqual(
538
538
            http.client.OK, response.status_code, response.content)
539
 
        parsed_device = json.loads(response.content)
 
539
        parsed_device = json_load_bytes(response.content)
540
540
        self.expectThat(parsed_device["ip_addresses"], HasLength(1))
541
541
 
542
542
    def test__rejected_if_not_permitted(self):