← Back to branch summary

~lutostag/ubuntu/trusty/maas/1.5.4+keystone

« back to all changes in this revision

Viewing changes to src/maasserver/views/tests/test_settings_clusters.py

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez
  • Date: 2014-02-15 12:08:23 UTC
  • mto: This revision was merged to the branch mainline in revision 48.
  • Revision ID: package-import@ubuntu.com-20140215120823-u7dkitfy0h8tbruh
Tags: upstream-1.5+bzr1948
Import upstream version 1.5+bzr1948

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/views/tests/test_settings_clusters.py
 
1
# Copyright 2012-2014 Canonical Ltd.  This software is licensed under the
 
2
# GNU Affero General Public License version 3 (see the file LICENSE).
 
3
 
 
4
"""Test maasserver clusters views."""
 
5
 
 
6
from __future__ import (
 
7
    absolute_import,
 
8
    print_function,
 
9
    unicode_literals,
 
10
    )
 
11
 
 
12
str = None
 
13
 
 
14
__metaclass__ = type
 
15
__all__ = []
 
16
 
 
17
import httplib
 
18
 
 
19
from django.core.urlresolvers import reverse
 
20
from maasserver.enum import (
 
21
    NODEGROUP_STATUS,
 
22
    NODEGROUPINTERFACE_MANAGEMENT,
 
23
    )
 
24
from maasserver.models import (
 
25
    NodeGroup,
 
26
    NodeGroupInterface,
 
27
    )
 
28
from maasserver.testing import (
 
29
    extract_redirect,
 
30
    get_content_links,
 
31
    reload_object,
 
32
    )
 
33
from maasserver.testing.factory import factory
 
34
from maasserver.testing.testcase import MAASServerTestCase
 
35
from testtools.matchers import (
 
36
    AllMatch,
 
37
    Contains,
 
38
    ContainsAll,
 
39
    Equals,
 
40
    MatchesStructure,
 
41
    )
 
42
 
 
43
 
 
44
class ClusterListingTest(MAASServerTestCase):
 
45
 
 
46
    def test_settings_contains_links_to_edit_and_delete_clusters(self):
 
47
        self.client_log_in(as_admin=True)
 
48
        nodegroups = {
 
49
            factory.make_node_group(status=NODEGROUP_STATUS.ACCEPTED),
 
50
            factory.make_node_group(status=NODEGROUP_STATUS.PENDING),
 
51
            factory.make_node_group(status=NODEGROUP_STATUS.REJECTED),
 
52
            }
 
53
        links = get_content_links(self.client.get(reverse('settings')))
 
54
        nodegroup_edit_links = [
 
55
            reverse('cluster-edit', args=[nodegroup.uuid])
 
56
            for nodegroup in nodegroups]
 
57
        nodegroup_delete_links = [
 
58
            reverse('cluster-delete', args=[nodegroup.uuid])
 
59
            for nodegroup in nodegroups]
 
60
        self.assertThat(
 
61
            links,
 
62
            ContainsAll(nodegroup_edit_links + nodegroup_delete_links))
 
63
 
 
64
 
 
65
class ClusterDeleteTest(MAASServerTestCase):
 
66
 
 
67
    def test_can_delete_cluster(self):
 
68
        self.client_log_in(as_admin=True)
 
69
        nodegroup = factory.make_node_group()
 
70
        delete_link = reverse('cluster-delete', args=[nodegroup.uuid])
 
71
        response = self.client.post(delete_link, {'post': 'yes'})
 
72
        self.assertEqual(
 
73
            (httplib.FOUND, reverse('settings')),
 
74
            (response.status_code, extract_redirect(response)))
 
75
        self.assertFalse(
 
76
            NodeGroup.objects.filter(uuid=nodegroup.uuid).exists())
 
77
 
 
78
 
 
79
class ClusterEditTest(MAASServerTestCase):
 
80
 
 
81
    def test_cluster_page_contains_links_to_edit_and_delete_interfaces(self):
 
82
        self.client_log_in(as_admin=True)
 
83
        nodegroup = factory.make_node_group()
 
84
        interfaces = set()
 
85
        for i in range(3):
 
86
            interface = factory.make_node_group_interface(
 
87
                nodegroup=nodegroup,
 
88
                management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
 
89
            interfaces.add(interface)
 
90
        links = get_content_links(
 
91
            self.client.get(reverse('cluster-edit', args=[nodegroup.uuid])))
 
92
        interface_edit_links = [
 
93
            reverse(
 
94
                'cluster-interface-edit',
 
95
                args=[nodegroup.uuid, interface.interface])
 
96
            for interface in interfaces]
 
97
        interface_delete_links = [
 
98
            reverse(
 
99
                'cluster-interface-delete',
 
100
                args=[nodegroup.uuid, interface.interface])
 
101
            for interface in interfaces]
 
102
        self.assertThat(
 
103
            links,
 
104
            ContainsAll(interface_edit_links + interface_delete_links))
 
105
 
 
106
    def test_can_edit_cluster(self):
 
107
        self.client_log_in(as_admin=True)
 
108
        nodegroup = factory.make_node_group()
 
109
        edit_link = reverse('cluster-edit', args=[nodegroup.uuid])
 
110
        data = {
 
111
            'cluster_name': factory.make_name('cluster_name'),
 
112
            'name': factory.make_name('name'),
 
113
            'status': factory.getRandomEnum(NODEGROUP_STATUS),
 
114
            }
 
115
        response = self.client.post(edit_link, data)
 
116
        self.assertEqual(httplib.FOUND, response.status_code, response.content)
 
117
        self.assertThat(
 
118
            reload_object(nodegroup),
 
119
            MatchesStructure.byEquality(**data))
 
120
 
 
121
    def test_contains_link_to_add_interface(self):
 
122
        self.client_log_in(as_admin=True)
 
123
        nodegroup = factory.make_node_group()
 
124
        links = get_content_links(
 
125
            self.client.get(reverse('cluster-edit', args=[nodegroup.uuid])))
 
126
        self.assertIn(
 
127
            reverse('cluster-interface-create', args=[nodegroup.uuid]), links)
 
128
 
 
129
 
 
130
class ClusterInterfaceDeleteTest(MAASServerTestCase):
 
131
 
 
132
    def test_can_delete_cluster_interface(self):
 
133
        self.client_log_in(as_admin=True)
 
134
        nodegroup = factory.make_node_group()
 
135
        interface = factory.make_node_group_interface(
 
136
            nodegroup=nodegroup,
 
137
            management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
 
138
        delete_link = reverse(
 
139
            'cluster-interface-delete',
 
140
            args=[nodegroup.uuid, interface.interface])
 
141
        response = self.client.post(delete_link, {'post': 'yes'})
 
142
        self.assertEqual(
 
143
            (httplib.FOUND, reverse('cluster-edit', args=[nodegroup.uuid])),
 
144
            (response.status_code, extract_redirect(response)))
 
145
        self.assertFalse(
 
146
            NodeGroupInterface.objects.filter(id=interface.id).exists())
 
147
 
 
148
    def test_interface_delete_supports_interface_alias(self):
 
149
        self.client_log_in(as_admin=True)
 
150
        nodegroup = factory.make_node_group(
 
151
            management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
 
152
        interface = factory.make_node_group_interface(
 
153
            nodegroup=nodegroup, interface="eth0:0")
 
154
        delete_link = reverse(
 
155
            'cluster-interface-delete',
 
156
            args=[nodegroup.uuid, interface.interface])
 
157
        # The real test is that reverse() does not blow up when the
 
158
        # interface's name contains an alias.
 
159
        self.assertIsInstance(delete_link, (bytes, unicode))
 
160
 
 
161
 
 
162
class ClusterInterfaceEditTest(MAASServerTestCase):
 
163
 
 
164
    def test_can_edit_cluster_interface(self):
 
165
        self.client_log_in(as_admin=True)
 
166
        nodegroup = factory.make_node_group(
 
167
            management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
 
168
        interface = factory.make_node_group_interface(
 
169
            nodegroup=nodegroup)
 
170
        edit_link = reverse(
 
171
            'cluster-interface-edit',
 
172
            args=[nodegroup.uuid, interface.interface])
 
173
        data = factory.get_interface_fields()
 
174
        response = self.client.post(edit_link, data)
 
175
        self.assertEqual(
 
176
            (httplib.FOUND, reverse('cluster-edit', args=[nodegroup.uuid])),
 
177
            (response.status_code, extract_redirect(response)))
 
178
        self.assertThat(
 
179
            reload_object(interface),
 
180
            MatchesStructure.byEquality(**data))
 
181
 
 
182
    def test_interface_edit_supports_interface_alias(self):
 
183
        self.client_log_in(as_admin=True)
 
184
        nodegroup = factory.make_node_group(
 
185
            management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
 
186
        interface = factory.make_node_group_interface(
 
187
            nodegroup=nodegroup, interface="eth0:0")
 
188
        edit_link = reverse(
 
189
            'cluster-interface-edit',
 
190
            args=[nodegroup.uuid, interface.interface])
 
191
        # The real test is that reverse() does not blow up when the
 
192
        # interface's name contains an alias.
 
193
        self.assertIsInstance(edit_link, (bytes, unicode))
 
194
 
 
195
 
 
196
class ClusterInterfaceCreateTest(MAASServerTestCase):
 
197
 
 
198
    def test_can_create_cluster_interface(self):
 
199
        self.client_log_in(as_admin=True)
 
200
        nodegroup = factory.make_node_group(
 
201
            management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
 
202
        create_link = reverse(
 
203
            'cluster-interface-create', args=[nodegroup.uuid])
 
204
        data = factory.get_interface_fields()
 
205
        response = self.client.post(create_link, data)
 
206
        self.assertEqual(
 
207
            (httplib.FOUND, reverse('cluster-edit', args=[nodegroup.uuid])),
 
208
            (response.status_code, extract_redirect(response)))
 
209
        interface = NodeGroupInterface.objects.get(
 
210
            nodegroup__uuid=nodegroup.uuid, interface=data['interface'])
 
211
        self.assertThat(
 
212
            reload_object(interface),
 
213
            MatchesStructure.byEquality(**data))
 
214
 
 
215
 
 
216
# XXX: rvb 2012-10-08 bug=1063881: apache transforms '//' into '/' in
 
217
# the urls it passes around and this happens when an interface has an empty
 
218
# name.
 
219
class ClusterInterfaceDoubleSlashBugTest(MAASServerTestCase):
 
220
 
 
221
    def test_edit_delete_empty_cluster_interface_when_slash_removed(self):
 
222
        self.client_log_in(as_admin=True)
 
223
        nodegroup = factory.make_node_group()
 
224
        interface = factory.make_node_group_interface(
 
225
            nodegroup=nodegroup, interface='',
 
226
            management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
 
227
        edit_link = reverse(
 
228
            'cluster-interface-edit',
 
229
            args=[nodegroup.uuid, interface.interface])
 
230
        delete_link = reverse(
 
231
            'cluster-interface-delete',
 
232
            args=[nodegroup.uuid, interface.interface])
 
233
        links = [edit_link, delete_link]
 
234
        # Just make sure that the urls contains '//'.  If this is not
 
235
        # true anymore, because we've refactored the urls, this test can
 
236
        # problably be removed.
 
237
        self.assertThat(links, AllMatch(Contains('//')))
 
238
        # Simulate what apache (when used as a frontend) does to the
 
239
        # urls.
 
240
        new_links = [link.replace('//', '/') for link in links]
 
241
        response_statuses = [
 
242
            self.client.get(link).status_code for link in new_links]
 
243
        self.assertThat(response_statuses, AllMatch(Equals(httplib.OK)))