← Back to branch summary

~ltrager/maas/lp1554636_2.0

« back to all changes in this revision

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

Merge Blake's branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/api/tests/test_ipaddresses.py
6
6
__all__ = []
7
7
 
8
8
import http.client
9
 
import json
10
9
 
 
10
from django.conf import settings
11
11
from django.core.urlresolvers import reverse
12
12
from maasserver.enum import (
13
13
    INTERFACE_LINK_TYPE,
24
24
from maasserver.testing.api import APITestCase
25
25
from maasserver.testing.factory import factory
26
26
from maasserver.testing.orm import reload_object
 
27
from maasserver.utils.converters import json_load_bytes
27
28
from maastesting.matchers import MockCalledOnceWith
28
29
from netaddr import IPAddress
29
30
from provisioningserver.rpc.exceptions import NoConnectionsAvailable
70
71
    def assertNoMatchingNetworkError(self, response, net):
71
72
        self.assertEqual(
72
73
            http.client.BAD_REQUEST, response.status_code, response.content)
73
 
        self.assertEqual(
 
74
        expected = (
74
75
            "No network found matching %s; you may be requesting an IP "
75
 
            "on a network with no static IP range defined." % str(net),
 
76
            "on a network with no static IP range defined." % str(net))
 
77
        self.assertEqual(
 
78
            expected.encode(settings.DEFAULT_CHARSET),
76
79
            response.content)
77
80
 
78
81
    def test_handler_path(self):
84
87
        net = interface.network
85
88
        response = self.post_reservation_request(net)
86
89
        self.assertEqual(http.client.OK, response.status_code)
87
 
        returned_address = json.loads(response.content)
 
90
        returned_address = json_load_bytes(response.content)
88
91
        [staticipaddress] = StaticIPAddress.objects.all()
89
92
        # We don't need to test the value of the 'created' datetime
90
93
        # field. By removing it, we also test for its presence.
107
110
 
108
111
        response = self.post_reservation_request(net=net, mac=mac)
109
112
        self.assertEqual(http.client.OK, response.status_code)
110
 
        returned_address = json.loads(response.content)
 
113
        returned_address = json_load_bytes(response.content)
111
114
        [staticipaddress] = StaticIPAddress.objects.all()
112
115
        self.expectThat(
113
116
            staticipaddress.interface_set.first().mac_address,
192
195
        self.assertEqual(
193
196
            http.client.BAD_REQUEST, response.status_code, response.content)
194
197
        self.assertEqual(
195
 
            "Invalid network parameter: %s" % net,
 
198
            ("Invalid network parameter: %s" % net).encode(
 
199
                settings.DEFAULT_CHARSET),
196
200
            response.content)
197
201
 
198
202
    def test_POST_reserve_creates_requested_address(self):
203
207
            net=net, requested_address=ip_in_network)
204
208
        self.assertEqual(
205
209
            http.client.OK, response.status_code, response.content)
206
 
        returned_address = json.loads(response.content)
 
210
        returned_address = json_load_bytes(response.content)
207
211
        [staticipaddress] = StaticIPAddress.objects.all()
208
212
        self.expectThat(
209
213
            returned_address["alloc_type"],
223
227
            net=net, requested_address=ip_in_network)
224
228
        self.assertEqual(
225
229
            http.client.OK, response.status_code, response.content)
226
 
        returned_address = json.loads(response.content)
 
230
        returned_address = json_load_bytes(response.content)
227
231
        [staticipaddress] = StaticIPAddress.objects.all()
228
232
        self.expectThat(
229
233
            returned_address["alloc_type"],
243
247
            net=net, requested_address=ip_in_network)
244
248
        self.expectThat(response.status_code, Equals(http.client.NOT_FOUND))
245
249
        self.expectThat(
246
 
            response.content, Equals(
247
 
                "The IP address %s is already in use." % ip_in_network))
 
250
            response.content, Equals((
 
251
                "The IP address %s is already in use." % ip_in_network).encode(
 
252
                settings.DEFAULT_CHARSET)))
248
253
 
249
254
    def test_POST_reserve_requested_address_rejects_ip_in_dynamic_range(self):
250
255
        interface = self.make_interface()
277
282
            net=net, requested_address=ip_in_network, hostname=hostname)
278
283
        self.assertEqual(
279
284
            http.client.OK, response.status_code, response.content)
280
 
        returned_address = json.loads(response.content)
 
285
        returned_address = json_load_bytes(response.content)
281
286
        [staticipaddress] = StaticIPAddress.objects.all()
282
287
        self.expectThat(
283
288
            returned_address["alloc_type"],
298
303
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
299
304
        self.assertEqual(
300
305
            dict(requested_address=["Enter a valid IPv4 or IPv6 address."]),
301
 
            json.loads(response.content))
 
306
            json_load_bytes(response.content))
302
307
 
303
308
    def test_POST_release_rejects_invalid_ip(self):
304
309
        response = self.post_release_request("1690.254.0.1")
305
310
        self.assertEqual(http.client.BAD_REQUEST, response.status_code)
306
311
        self.assertEqual(
307
312
            dict(ip=["Enter a valid IPv4 or IPv6 address."]),
308
 
            json.loads(response.content))
 
313
            json_load_bytes(response.content))
309
314
 
310
315
    def test_GET_returns_ipaddresses(self):
311
316
        original_ipaddress = factory.make_StaticIPAddress(
314
319
        self.assertEqual(
315
320
            http.client.OK, response.status_code, response.content)
316
321
 
317
 
        parsed_result = json.loads(response.content)
 
322
        parsed_result = json_load_bytes(response.content)
318
323
        self.assertEqual(1, len(parsed_result), response.content)
319
324
        [returned_address] = parsed_result
320
325
        fields = {'alloc_type', 'ip'}
336
341
        response = self.client.get(reverse('ipaddresses_handler'))
337
342
        self.assertEqual(
338
343
            http.client.OK, response.status_code, response.content)
339
 
        self.assertEqual([], json.loads(response.content))
 
344
        self.assertEqual([], json_load_bytes(response.content))
340
345
 
341
346
    def test_GET_only_returns_request_users_addresses(self):
342
347
        ipaddress = factory.make_StaticIPAddress(user=self.logged_in_user)
344
349
        response = self.client.get(reverse('ipaddresses_handler'))
345
350
        self.assertEqual(
346
351
            http.client.OK, response.status_code, response.content)
347
 
        parsed_result = json.loads(response.content)
 
352
        parsed_result = json_load_bytes(response.content)
348
353
        [returned_address] = parsed_result
349
354
        self.assertEqual(ipaddress.ip, returned_address['ip'])
350
355
 
356
361
        response = self.client.get(reverse('ipaddresses_handler'))
357
362
        self.assertEqual(
358
363
            http.client.OK, response.status_code, response.content)
359
 
        parsed_result = json.loads(response.content)
 
364
        parsed_result = json_load_bytes(response.content)
360
365
        expected = [
361
366
            addr.ip for addr in
362
367
            sorted(addrs, key=lambda addr: getattr(addr, "id"))]