← Back to branch summary

~andreserl/maas/lp1592666

« back to all changes in this revision

Viewing changes to src/maasserver/websockets/handlers/tests/test_dhcpsnippet.py

  • Committer: LaMont Jones
  • Date: 2016-04-11 16:23:26 UTC
  • mfrom: (4900 maas)
  • mto: This revision was merged to the branch mainline in revision 4924.
  • Revision ID: lamont@canonical.com-20160411162326-6ycj8l2j66v2o5es
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/websockets/handlers/tests/test_dhcpsnippet.py
 
1
# Copyright 2016 Canonical Ltd.  This software is licensed under the
 
2
# GNU Affero General Public License version 3 (see the file LICENSE).
 
3
 
 
4
"""Tests for `maasserver.websockets.handlers.dhcpsnippet`"""
 
5
 
 
6
__all__ = []
 
7
 
 
8
from email.utils import format_datetime
 
9
import random
 
10
 
 
11
import maasserver.forms_dhcpsnippet as forms_dhcpsnippet_module
 
12
from maasserver.models import (
 
13
    DHCPSnippet,
 
14
    VersionedTextFile,
 
15
)
 
16
from maasserver.testing.factory import factory
 
17
from maasserver.testing.testcase import MAASServerTestCase
 
18
from maasserver.utils.orm import reload_object
 
19
from maasserver.websockets.base import (
 
20
    HandlerPermissionError,
 
21
    HandlerValidationError,
 
22
)
 
23
from maasserver.websockets.handlers.dhcpsnippet import DHCPSnippetHandler
 
24
from maasserver.websockets.handlers.timestampedmodel import dehydrate_datetime
 
25
 
 
26
 
 
27
class TestDHCPSnippetHandler(MAASServerTestCase):
 
28
 
 
29
    def setUp(self):
 
30
        super().setUp()
 
31
        self.patch(
 
32
            forms_dhcpsnippet_module, 'validate_dhcp_config').return_value = []
 
33
 
 
34
    def dehydrate_dhcp_snippet(self, dhcp_snippet):
 
35
        node_system_id = None
 
36
        subnet_id = None
 
37
        if dhcp_snippet.subnet is not None:
 
38
            subnet_id = dhcp_snippet.subnet.id
 
39
        elif dhcp_snippet.node is not None:
 
40
            node_system_id = dhcp_snippet.node.system_id
 
41
        return {
 
42
            'id': dhcp_snippet.id,
 
43
            'name': dhcp_snippet.name,
 
44
            'description': dhcp_snippet.description,
 
45
            'value': dhcp_snippet.value.data,
 
46
            'history': [
 
47
                {
 
48
                    'id': value.id,
 
49
                    'value': value.data,
 
50
                    'created': format_datetime(value.created),
 
51
                }
 
52
                for value in dhcp_snippet.value.previous_versions()],
 
53
            'enabled': dhcp_snippet.enabled,
 
54
            'node': node_system_id,
 
55
            'subnet': subnet_id,
 
56
            'updated': dehydrate_datetime(dhcp_snippet.updated),
 
57
            'created': dehydrate_datetime(dhcp_snippet.created),
 
58
        }
 
59
 
 
60
    def test_get_global(self):
 
61
        user = factory.make_User()
 
62
        handler = DHCPSnippetHandler(user, {})
 
63
        dhcp_snippet = factory.make_DHCPSnippet()
 
64
        self.assertEqual(
 
65
            self.dehydrate_dhcp_snippet(dhcp_snippet),
 
66
            handler.get({'id': dhcp_snippet.id}))
 
67
 
 
68
    def test_get_with_subnet(self):
 
69
        user = factory.make_User()
 
70
        handler = DHCPSnippetHandler(user, {})
 
71
        subnet = factory.make_Subnet()
 
72
        dhcp_snippet = factory.make_DHCPSnippet(subnet=subnet)
 
73
        self.assertEqual(
 
74
            self.dehydrate_dhcp_snippet(dhcp_snippet),
 
75
            handler.get({'id': dhcp_snippet.id}))
 
76
 
 
77
    def test_get_with_node(self):
 
78
        user = factory.make_User()
 
79
        handler = DHCPSnippetHandler(user, {})
 
80
        node = factory.make_Node()
 
81
        dhcp_snippet = factory.make_DHCPSnippet(node=node)
 
82
        self.assertEqual(
 
83
            self.dehydrate_dhcp_snippet(dhcp_snippet),
 
84
            handler.get({'id': dhcp_snippet.id}))
 
85
 
 
86
    def test_list(self):
 
87
        user = factory.make_User()
 
88
        handler = DHCPSnippetHandler(user, {})
 
89
        expected_dhcp_snippets = [
 
90
            self.dehydrate_dhcp_snippet(factory.make_DHCPSnippet())
 
91
            for _ in range(3)
 
92
        ]
 
93
        self.assertItemsEqual(expected_dhcp_snippets, handler.list({}))
 
94
 
 
95
    def test_create_is_admin_only(self):
 
96
        user = factory.make_User()
 
97
        handler = DHCPSnippetHandler(user, {})
 
98
        self.assertRaises(
 
99
            HandlerPermissionError,
 
100
            handler.create, {})
 
101
 
 
102
    def test_create(self):
 
103
        user = factory.make_admin()
 
104
        handler = DHCPSnippetHandler(user, {})
 
105
        dhcp_snippet_name = factory.make_name('dhcp_snippet_name')
 
106
        handler.create({
 
107
            'name': dhcp_snippet_name,
 
108
            'value': factory.make_string(),
 
109
        })
 
110
        self.assertIsNotNone(DHCPSnippet.objects.get(name=dhcp_snippet_name))
 
111
 
 
112
    def test_update_is_admin_only(self):
 
113
        user = factory.make_User()
 
114
        handler = DHCPSnippetHandler(user, {})
 
115
        self.assertRaises(
 
116
            HandlerPermissionError,
 
117
            handler.update, {})
 
118
 
 
119
    def test_update(self):
 
120
        user = factory.make_admin()
 
121
        handler = DHCPSnippetHandler(user, {})
 
122
        dhcp_snippet = factory.make_DHCPSnippet()
 
123
        node = factory.make_Node()
 
124
        handler.update({
 
125
            'id': dhcp_snippet.id,
 
126
            'node': node.system_id
 
127
        })
 
128
        dhcp_snippet = reload_object(dhcp_snippet)
 
129
        self.assertEquals(node, dhcp_snippet.node)
 
130
 
 
131
    def test_delete_is_admin_only(self):
 
132
        user = factory.make_User()
 
133
        handler = DHCPSnippetHandler(user, {})
 
134
        self.assertRaises(
 
135
            HandlerPermissionError,
 
136
            handler.delete, {})
 
137
 
 
138
    def test_delete(self):
 
139
        user = factory.make_admin()
 
140
        handler = DHCPSnippetHandler(user, {})
 
141
        dhcp_snippet = factory.make_DHCPSnippet()
 
142
        handler.delete({'id': dhcp_snippet.id})
 
143
        self.assertRaises(
 
144
            DHCPSnippet.DoesNotExist,
 
145
            DHCPSnippet.objects.get, id=dhcp_snippet.id)
 
146
 
 
147
    def test_revert_is_admin_only(self):
 
148
        user = factory.make_User()
 
149
        handler = DHCPSnippetHandler(user, {})
 
150
        self.assertRaises(
 
151
            HandlerPermissionError,
 
152
            handler.delete, {})
 
153
 
 
154
    def test_revert(self):
 
155
        user = factory.make_admin()
 
156
        handler = DHCPSnippetHandler(user, {})
 
157
        dhcp_snippet = factory.make_DHCPSnippet()
 
158
        textfile_ids = [dhcp_snippet.value.id]
 
159
        for _ in range(10):
 
160
            dhcp_snippet.value = dhcp_snippet.value.update(
 
161
                factory.make_string())
 
162
            dhcp_snippet.save()
 
163
            textfile_ids.append(dhcp_snippet.value.id)
 
164
        revert_to = random.randint(-10, -1)
 
165
        reverted_ids = textfile_ids[revert_to:]
 
166
        remaining_ids = textfile_ids[:revert_to]
 
167
        handler.revert({'id': dhcp_snippet.id, 'to': revert_to})
 
168
        dhcp_snippet = reload_object(dhcp_snippet)
 
169
        self.assertEquals(
 
170
            VersionedTextFile.objects.get(
 
171
                id=textfile_ids[revert_to - 1]).data,
 
172
            dhcp_snippet.value.data)
 
173
        for i in reverted_ids:
 
174
            self.assertRaises(
 
175
                VersionedTextFile.DoesNotExist,
 
176
                VersionedTextFile.objects.get, id=i)
 
177
        for i in remaining_ids:
 
178
            self.assertIsNotNone(VersionedTextFile.objects.get(id=i))
 
179
 
 
180
    def test_revert_requires_to(self):
 
181
        user = factory.make_admin()
 
182
        handler = DHCPSnippetHandler(user, {})
 
183
        dhcp_snippet = factory.make_DHCPSnippet()
 
184
        self.assertRaises(
 
185
            HandlerValidationError,
 
186
            handler.revert, {'id': dhcp_snippet.id})
 
187
 
 
188
    def test_revert_requires_to_to_be_an_int(self):
 
189
        user = factory.make_admin()
 
190
        handler = DHCPSnippetHandler(user, {})
 
191
        dhcp_snippet = factory.make_DHCPSnippet()
 
192
        self.assertRaises(
 
193
            HandlerValidationError,
 
194
            handler.revert,
 
195
            {'id': dhcp_snippet.id, 'to': factory.make_name('to')})
 
196
 
 
197
    def test_revert_errors_on_invalid_id(self):
 
198
        user = factory.make_admin()
 
199
        handler = DHCPSnippetHandler(user, {})
 
200
        dhcp_snippet = factory.make_DHCPSnippet()
 
201
        textfile = VersionedTextFile.objects.create(data=factory.make_string())
 
202
        self.assertRaises(
 
203
            HandlerValidationError,
 
204
            handler.revert,
 
205
            {'id': dhcp_snippet.id, 'to': textfile.id})