← Back to branch summary

~ubuntu-branches/ubuntu/raring/horizon/raring

« back to all changes in this revision

Viewing changes to horizon/tests/base_tests.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-05-24 14:33:20 UTC
  • mfrom: (1.1.14)
  • Revision ID: package-import@ubuntu.com-20120524143320-i7eswfq6ecxlvh5a
Tags: 2012.2~f1-0ubuntu1
* New usptream release. 
* Prepare for quantal:
  - debian/patches/fix-coverage-binary-name.patch: Refreshed.
* Temporarily pass the testsuite.

Show diffs side-by-side

added added

removed removed

Lines of Context:
horizon/tests/base_tests.py
21
21
 
22
22
from django.conf import settings
23
23
from django.core import urlresolvers
24
 
from django import http
25
24
from django.test.client import Client
26
25
from django.utils.importlib import import_module
27
 
from mox import IsA
 
26
from django.utils.translation import ugettext_lazy as _
28
27
 
29
28
import horizon
30
 
from horizon import api
31
29
from horizon import base
32
30
from horizon import test
33
31
from horizon import users
 
32
from horizon.dashboards.nova.dashboard import Nova
 
33
from horizon.dashboards.syspanel.dashboard import Syspanel
 
34
from horizon.dashboards.settings.dashboard import Settings
 
35
from horizon.tests.test_dashboards.cats.dashboard import Cats
 
36
from horizon.tests.test_dashboards.cats.kittens.panel import Kittens
 
37
from horizon.tests.test_dashboards.cats.tigers.panel import Tigers
 
38
from horizon.tests.test_dashboards.dogs.dashboard import Dogs
 
39
from horizon.tests.test_dashboards.dogs.puppies.panel import Puppies
34
40
 
35
41
 
36
42
class MyDash(horizon.Dashboard):
37
 
    name = "My Dashboard"
 
43
    name = _("My Dashboard")
38
44
    slug = "mydash"
39
45
    default_panel = "myslug"
40
46
 
41
47
 
42
48
class MyPanel(horizon.Panel):
43
 
    name = "My Panel"
 
49
    name = _("My Panel")
44
50
    slug = "myslug"
45
51
    services = ("compute",)
46
52
    urls = 'horizon.tests.test_panel_urls'
47
53
 
48
54
 
 
55
class AdminPanel(horizon.Panel):
 
56
    name = _("Admin Panel")
 
57
    slug = "admin_panel"
 
58
    roles = ("admin",)
 
59
    urls = 'horizon.tests.test_panel_urls'
 
60
 
 
61
 
49
62
class BaseHorizonTests(test.TestCase):
50
63
    def setUp(self):
51
64
        super(BaseHorizonTests, self).setUp()
 
65
        # Adjust our horizon config and register our custom dashboards/panels.
 
66
        self.old_default_dash = settings.HORIZON_CONFIG['default_dashboard']
 
67
        settings.HORIZON_CONFIG['default_dashboard'] = 'cats'
 
68
        self.old_dashboards = settings.HORIZON_CONFIG['dashboards']
 
69
        settings.HORIZON_CONFIG['dashboards'] = ('cats', 'dogs')
 
70
        base.Horizon.register(Cats)
 
71
        base.Horizon.register(Dogs)
 
72
        Cats.register(Kittens)
 
73
        Cats.register(Tigers)
 
74
        Dogs.register(Puppies)
52
75
        # Trigger discovery, registration, and URLconf generation if it
53
76
        # hasn't happened yet.
54
77
        base.Horizon._urls()
59
82
        for dash in self._discovered_dashboards:
60
83
            panels = base.Horizon._registry[dash]._registry.keys()
61
84
            self._discovered_panels[dash] = panels
 
85
        # Remove the OpenStack dashboards for test isolation.
 
86
        base.Horizon.unregister(Nova)
 
87
        base.Horizon.unregister(Syspanel)
 
88
        base.Horizon.unregister(Settings)
62
89
 
63
90
    def tearDown(self):
64
91
        super(BaseHorizonTests, self).tearDown()
 
92
        # Restore our settings
 
93
        settings.HORIZON_CONFIG['default_dashboard'] = self.old_default_dash
 
94
        settings.HORIZON_CONFIG['dashboards'] = self.old_dashboards
65
95
        # Destroy our singleton and re-create it.
66
96
        base.HorizonSite._instance = None
67
97
        del base.Horizon
68
98
        base.Horizon = base.HorizonSite()
 
99
        # Re-register the OpenStack dashboards that we removed.
 
100
        base.Horizon.register(Nova)
 
101
        base.Horizon.register(Syspanel)
 
102
        base.Horizon.register(Settings)
69
103
        # Reload the convenience references to Horizon stored in __init__
70
104
        reload(import_module("horizon"))
71
105
        # Re-register our original dashboards and panels.
72
106
        # This is necessary because autodiscovery only works on the first
73
107
        # import, and calling reload introduces innumerable additional
74
108
        # problems. Manual re-registration is the only good way for testing.
 
109
        self._discovered_dashboards.remove(Cats)
 
110
        self._discovered_dashboards.remove(Dogs)
75
111
        for dash in self._discovered_dashboards:
76
112
            base.Horizon.register(dash)
77
113
            for panel in self._discovered_panels[dash]:
98
134
        ``settings.INSTALLED_APPS`` are loaded from the start.
99
135
        """
100
136
        # Registration
 
137
        self.assertEqual(len(base.Horizon._registry), 2)
 
138
        horizon.register(MyDash)
101
139
        self.assertEqual(len(base.Horizon._registry), 3)
102
 
        horizon.register(MyDash)
103
 
        self.assertEqual(len(base.Horizon._registry), 4)
104
140
        with self.assertRaises(ValueError):
105
141
            horizon.register(MyPanel)
106
142
        with self.assertRaises(ValueError):
114
150
        with self.assertRaises(base.NotRegistered):
115
151
            horizon.get_dashboard("fake")
116
152
        self.assertQuerysetEqual(horizon.get_dashboards(),
117
 
                                 ['<Dashboard: nova>',
118
 
                                  '<Dashboard: syspanel>',
119
 
                                  '<Dashboard: settings>',
 
153
                                 ['<Dashboard: cats>',
 
154
                                  '<Dashboard: dogs>',
120
155
                                  '<Dashboard: mydash>'])
121
156
 
122
157
        # Removal
123
 
        self.assertEqual(len(base.Horizon._registry), 4)
 
158
        self.assertEqual(len(base.Horizon._registry), 3)
124
159
        horizon.unregister(MyDash)
125
 
        self.assertEqual(len(base.Horizon._registry), 3)
 
160
        self.assertEqual(len(base.Horizon._registry), 2)
126
161
        with self.assertRaises(base.NotRegistered):
127
162
            horizon.get_dashboard(MyDash)
128
163
 
129
164
    def test_site(self):
130
165
        self.assertEqual(unicode(base.Horizon), "Horizon")
131
166
        self.assertEqual(repr(base.Horizon), "<Site: horizon>")
132
 
        dash = base.Horizon.get_dashboard('nova')
 
167
        dash = base.Horizon.get_dashboard('cats')
133
168
        self.assertEqual(base.Horizon.get_default_dashboard(), dash)
134
169
        user = users.User()
135
170
        self.assertEqual(base.Horizon.get_user_home(user),
136
171
                         dash.get_absolute_url())
137
172
 
138
173
    def test_dashboard(self):
139
 
        syspanel = horizon.get_dashboard("syspanel")
140
 
        self.assertEqual(syspanel._registered_with, base.Horizon)
141
 
        self.assertQuerysetEqual(syspanel.get_panels(),
142
 
                                 ['<Panel: overview>',
143
 
                                 '<Panel: instances>',
144
 
                                 '<Panel: services>',
145
 
                                 '<Panel: flavors>',
146
 
                                 '<Panel: images>',
147
 
                                 '<Panel: projects>',
148
 
                                 '<Panel: users>',
149
 
                                 '<Panel: quotas>'])
150
 
        self.assertEqual(syspanel.get_absolute_url(), "/syspanel/")
 
174
        cats = horizon.get_dashboard("cats")
 
175
        self.assertEqual(cats._registered_with, base.Horizon)
 
176
        self.assertQuerysetEqual(cats.get_panels(),
 
177
                                 ['<Panel: kittens>',
 
178
                                  '<Panel: tigers>'])
 
179
        self.assertEqual(cats.get_absolute_url(), "/cats/")
151
180
 
152
181
        # Test registering a module with a dashboard that defines panels
153
 
        # as a dictionary.
154
 
        syspanel.register(MyPanel)
155
 
        self.assertQuerysetEqual(syspanel.get_panel_groups()['other'],
 
182
        # as a panel group.
 
183
        cats.register(MyPanel)
 
184
        self.assertQuerysetEqual(cats.get_panel_groups()['other'],
156
185
                                 ['<Panel: myslug>'])
157
186
 
158
187
        # Test that panels defined as a tuple still return a PanelGroup
159
 
        settings_dash = horizon.get_dashboard("settings")
160
 
        self.assertQuerysetEqual(settings_dash.get_panel_groups().values(),
 
188
        dogs = horizon.get_dashboard("dogs")
 
189
        self.assertQuerysetEqual(dogs.get_panel_groups().values(),
161
190
                                 ['<PanelGroup: default>'])
162
191
 
163
192
        # Test registering a module with a dashboard that defines panels
164
193
        # as a tuple.
165
 
        settings_dash = horizon.get_dashboard("settings")
166
 
        settings_dash.register(MyPanel)
167
 
        self.assertQuerysetEqual(settings_dash.get_panels(),
168
 
                                 ['<Panel: user>',
169
 
                                  '<Panel: project>',
170
 
                                  '<Panel: ec2>',
 
194
        dogs = horizon.get_dashboard("dogs")
 
195
        dogs.register(MyPanel)
 
196
        self.assertQuerysetEqual(dogs.get_panels(),
 
197
                                 ['<Panel: puppies>',
171
198
                                  '<Panel: myslug>'])
172
199
 
173
200
    def test_panels(self):
174
 
        syspanel = horizon.get_dashboard("syspanel")
175
 
        instances = syspanel.get_panel("instances")
176
 
        self.assertEqual(instances._registered_with, syspanel)
177
 
        self.assertEqual(instances.get_absolute_url(), "/syspanel/instances/")
 
201
        cats = horizon.get_dashboard("cats")
 
202
        tigers = cats.get_panel("tigers")
 
203
        self.assertEqual(tigers._registered_with, cats)
 
204
        self.assertEqual(tigers.get_absolute_url(), "/cats/tigers/")
178
205
 
179
206
    def test_index_url_name(self):
180
 
        syspanel = horizon.get_dashboard("syspanel")
181
 
        instances = syspanel.get_panel("instances")
182
 
        instances.index_url_name = "does_not_exist"
 
207
        cats = horizon.get_dashboard("cats")
 
208
        tigers = cats.get_panel("tigers")
 
209
        tigers.index_url_name = "does_not_exist"
183
210
        with self.assertRaises(urlresolvers.NoReverseMatch):
184
 
            instances.get_absolute_url()
185
 
        instances.index_url_name = "index"
186
 
        self.assertEqual(instances.get_absolute_url(), "/syspanel/instances/")
 
211
            tigers.get_absolute_url()
 
212
        tigers.index_url_name = "index"
 
213
        self.assertEqual(tigers.get_absolute_url(), "/cats/tigers/")
187
214
 
188
215
    def test_lazy_urls(self):
189
216
        urlpatterns = horizon.urls[0]
194
221
 
195
222
    def test_horizon_test_isolation_1(self):
196
223
        """ Isolation Test Part 1: sets a value. """
197
 
        syspanel = horizon.get_dashboard("syspanel")
198
 
        syspanel.evil = True
 
224
        cats = horizon.get_dashboard("cats")
 
225
        cats.evil = True
199
226
 
200
227
    def test_horizon_test_isolation_2(self):
201
228
        """ Isolation Test Part 2: The value set in part 1 should be gone. """
202
 
        syspanel = horizon.get_dashboard("syspanel")
203
 
        self.assertFalse(hasattr(syspanel, "evil"))
 
229
        cats = horizon.get_dashboard("cats")
 
230
        self.assertFalse(hasattr(cats, "evil"))
204
231
 
205
232
    def test_public(self):
206
233
        users.get_user_from_request = self._real_get_user_from_request
207
 
        settings = horizon.get_dashboard("settings")
 
234
        dogs = horizon.get_dashboard("dogs")
208
235
        # Known to have no restrictions on it other than being logged in.
209
 
        user_panel = settings.get_panel("user")
210
 
        url = user_panel.get_absolute_url()
 
236
        puppies = dogs.get_panel("puppies")
 
237
        url = puppies.get_absolute_url()
211
238
        # Get a clean, logged out client instance.
212
239
        client = Client()
213
240
        client.logout()
248
275
        self.assertEqual(resp.status_code, 404)
249
276
 
250
277
    def test_required_roles(self):
251
 
        syspanel = horizon.get_dashboard("syspanel")
252
 
        user_panel = syspanel.get_panel("users")
 
278
        dash = horizon.get_dashboard("cats")
 
279
        panel = dash.get_panel('tigers')
253
280
 
254
281
        # Non-admin user
255
282
        self.setActiveUser(token=self.token.id,
258
285
                           service_catalog=self.service_catalog,
259
286
                           roles=[])
260
287
 
261
 
        resp = self.client.get(user_panel.get_absolute_url())
 
288
        resp = self.client.get(panel.get_absolute_url())
262
289
        self.assertEqual(resp.status_code, 302)
263
290
 
264
 
        resp = self.client.get(user_panel.get_absolute_url(),
 
291
        resp = self.client.get(panel.get_absolute_url(),
265
292
                               follow=False,
266
293
                               HTTP_X_REQUESTED_WITH='XMLHttpRequest')
267
294
        self.assertEqual(resp.status_code, 401)
268
295
 
269
 
        self.mox.StubOutWithMock(api, 'flavor_list')
270
 
        api.flavor_list(IsA(http.HttpRequest)).AndReturn(self.flavors.list())
271
 
        api.flavor_list(IsA(http.HttpRequest)).AndReturn(self.flavors.list())
272
 
        self.mox.ReplayAll()
273
 
 
274
296
        # Set roles for admin user
275
297
        self.setActiveUser(token=self.token.id,
276
298
                           username=self.user.name,
278
300
                           service_catalog=self.request.user.service_catalog,
279
301
                           roles=[{'name': 'admin'}])
280
302
 
281
 
        resp = self.client.get(
282
 
                    urlresolvers.reverse('horizon:syspanel:flavors:create'))
 
303
        resp = self.client.get(panel.get_absolute_url())
283
304
        self.assertEqual(resp.status_code, 200)
284
 
        self.assertTemplateUsed(resp, "syspanel/flavors/create.html")
285
305
 
286
306
        # Test modal form
287
 
        resp = self.client.get(
288
 
                    urlresolvers.reverse('horizon:syspanel:flavors:create'),
289
 
                    follow=False,
290
 
                    HTTP_X_REQUESTED_WITH='XMLHttpRequest')
 
307
        resp = self.client.get(panel.get_absolute_url(),
 
308
                               follow=False,
 
309
                               HTTP_X_REQUESTED_WITH='XMLHttpRequest')
291
310
        self.assertEqual(resp.status_code, 200)
292
 
        self.assertTemplateUsed(resp, "syspanel/flavors/_create.html")