← Back to branch summary

~ubuntu-branches/ubuntu/precise/horizon/precise-updates

« back to all changes in this revision

Viewing changes to horizon/horizon/dashboards/nova/containers/tests.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2012-02-17 10:12:25 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120217101225-5wulil2mv7f2nvnb
Tags: 2012.1~e4~20120217.1354-0ubuntu1
* debian/patches/openstack-config-settings.patch: Refreshed.
* debian/copyright: Updated copyright.
* debian/rules: Diable tests since it doesnt work without a
  virtualenv.
* New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
horizon/horizon/dashboards/nova/containers/tests.py
1
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2
2
 
3
 
# Copyright 2011 United States Government as represented by the
 
3
# Copyright 2012 United States Government as represented by the
4
4
# Administrator of the National Aeronautics and Space Administration.
5
5
# All Rights Reserved.
6
6
#
7
 
# Copyright 2011 Nebula, Inc.
 
7
# Copyright 2012 Nebula, Inc.
8
8
#
9
9
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
10
10
#    not use this file except in compliance with the License. You may obtain
28
28
from horizon import api
29
29
from horizon import test
30
30
from .tables import ContainersTable, ObjectsTable
 
31
from . import forms
31
32
 
32
33
 
33
34
CONTAINER_INDEX_URL = reverse('horizon:nova:containers:index')
34
35
 
35
36
 
36
 
class ContainerViewTests(test.BaseViewTests):
37
 
    def setUp(self):
38
 
        super(ContainerViewTests, self).setUp()
39
 
        self.container = api.Container(None)
40
 
        self.container.name = 'containerName'
41
 
        self.container.size_used = 128
42
 
        self.containers = (self.container,)
43
 
 
 
37
class ContainerViewTests(test.TestCase):
44
38
    def test_index(self):
 
39
        containers = self.containers.list()
45
40
        self.mox.StubOutWithMock(api, 'swift_get_containers')
46
 
        api.swift_get_containers(
47
 
                IsA(http.HttpRequest), marker=None).AndReturn(
48
 
                        ([self.container], False))
49
 
 
 
41
        api.swift_get_containers(IsA(http.HttpRequest), marker=None) \
 
42
                                .AndReturn((containers, False))
50
43
        self.mox.ReplayAll()
51
44
 
52
45
        res = self.client.get(CONTAINER_INDEX_URL)
53
46
 
54
47
        self.assertTemplateUsed(res, 'nova/containers/index.html')
55
48
        self.assertIn('table', res.context)
56
 
        containers = res.context['table'].data
57
 
 
58
 
        self.assertEqual(len(containers), 1)
59
 
        self.assertEqual(containers[0].name, 'containerName')
 
49
        resp_containers = res.context['table'].data
 
50
        self.assertEqual(len(resp_containers), len(containers))
60
51
 
61
52
    def test_delete_container(self):
62
 
        self.mox.StubOutWithMock(api, 'swift_delete_container')
 
53
        container = self.containers.get(name="container_two")
 
54
        self.mox.StubOutWithMock(api, 'swift_delete_container')
 
55
        api.swift_delete_container(IsA(http.HttpRequest), container.name)
 
56
        self.mox.ReplayAll()
 
57
 
 
58
        action_string = "containers__delete__%s" % container.name
 
59
        form_data = {"action": action_string}
 
60
        req = self.factory.post(CONTAINER_INDEX_URL, form_data)
 
61
        table = ContainersTable(req, self.containers.list())
 
62
        handled = table.maybe_handle()
 
63
        self.assertEqual(handled['location'], CONTAINER_INDEX_URL)
 
64
 
 
65
    def test_delete_container_nonempty(self):
 
66
        container = self.containers.first()
 
67
        self.mox.StubOutWithMock(api, 'swift_delete_container')
 
68
        exc = ContainerNotEmpty('containerNotEmpty')
63
69
        api.swift_delete_container(IsA(http.HttpRequest),
64
 
                                   'containerName')
65
 
 
66
 
        self.mox.ReplayAll()
67
 
 
68
 
        action_string = "containers__delete__%s" % self.container.name
69
 
        form_data = {"action": action_string}
70
 
        req = self.factory.post(CONTAINER_INDEX_URL, form_data)
71
 
        table = ContainersTable(req, self.containers)
72
 
        handled = table.maybe_handle()
73
 
 
74
 
        self.assertEqual(handled['location'], CONTAINER_INDEX_URL)
75
 
 
76
 
    def test_delete_container_nonempty(self):
77
 
        self.mox.StubOutWithMock(api, 'swift_delete_container')
78
 
 
79
 
        exception = ContainerNotEmpty('containerNotEmpty')
80
 
        api.swift_delete_container(
81
 
                IsA(http.HttpRequest),
82
 
                'containerName').AndRaise(exception)
83
 
 
84
 
        self.mox.ReplayAll()
85
 
 
86
 
        action_string = "containers__delete__%s" % self.container.name
87
 
        form_data = {"action": action_string}
88
 
        req = self.factory.post(CONTAINER_INDEX_URL, form_data)
89
 
        table = ContainersTable(req, self.containers)
90
 
        handled = table.maybe_handle()
91
 
 
 
70
                                   container.name).AndRaise(exc)
 
71
        self.mox.ReplayAll()
 
72
 
 
73
        action_string = "containers__delete__%s" % container.name
 
74
        form_data = {"action": action_string}
 
75
        req = self.factory.post(CONTAINER_INDEX_URL, form_data)
 
76
        table = ContainersTable(req, self.containers.list())
 
77
        handled = table.maybe_handle()
92
78
        self.assertEqual(handled['location'], CONTAINER_INDEX_URL)
93
79
 
94
80
    def test_create_container_get(self):
95
81
        res = self.client.get(reverse('horizon:nova:containers:create'))
96
 
 
97
82
        self.assertTemplateUsed(res, 'nova/containers/create.html')
98
83
 
99
84
    def test_create_container_post(self):
100
 
        formData = {'name': 'containerName',
101
 
                    'method': 'CreateContainer'}
102
 
 
103
85
        self.mox.StubOutWithMock(api, 'swift_create_container')
104
 
        api.swift_create_container(
105
 
                IsA(http.HttpRequest), u'containerName')
106
 
 
 
86
        api.swift_create_container(IsA(http.HttpRequest),
 
87
                                   self.containers.first().name)
107
88
        self.mox.ReplayAll()
108
89
 
 
90
        formData = {'name': self.containers.first().name,
 
91
                    'method': forms.CreateContainer.__name__}
109
92
        res = self.client.post(reverse('horizon:nova:containers:create'),
110
93
                               formData)
111
 
 
112
94
        self.assertRedirectsNoFollow(res, CONTAINER_INDEX_URL)
113
95
 
114
96
 
115
 
class ObjectViewTests(test.BaseViewTests):
116
 
    CONTAINER_NAME = 'containerName'
117
 
 
118
 
    def setUp(self):
119
 
        class FakeCloudFile(object):
120
 
            def __init__(self):
121
 
                self.metadata = {}
122
 
 
123
 
            def sync_metadata(self):
124
 
                pass
125
 
 
126
 
        super(ObjectViewTests, self).setUp()
127
 
        swift_object = api.swift.SwiftObject(FakeCloudFile())
128
 
        swift_object.name = u"test_object"
129
 
        swift_object.size = '128'
130
 
        swift_object.container = api.swift.Container(None)
131
 
        swift_object.container.name = self.CONTAINER_NAME
132
 
        self.swift_objects = [swift_object]
133
 
 
 
97
class ObjectViewTests(test.TestCase):
134
98
    def test_index(self):
135
99
        self.mox.StubOutWithMock(api, 'swift_get_objects')
136
 
        api.swift_get_objects(
137
 
                IsA(http.HttpRequest),
138
 
                self.CONTAINER_NAME,
139
 
                marker=None).AndReturn((self.swift_objects, False))
140
 
 
 
100
        ret = (self.objects.list(), False)
 
101
        api.swift_get_objects(IsA(http.HttpRequest),
 
102
                              self.containers.first().name,
 
103
                              marker=None).AndReturn(ret)
141
104
        self.mox.ReplayAll()
142
105
 
143
106
        res = self.client.get(reverse('horizon:nova:containers:object_index',
144
 
                                      args=[self.CONTAINER_NAME]))
 
107
                                      args=[self.containers.first().name]))
145
108
        self.assertTemplateUsed(res, 'nova/objects/index.html')
146
 
        self.assertItemsEqual(res.context['table'].data, self.swift_objects)
 
109
        expected = [obj.name for obj in self.objects.list()]
 
110
        self.assertQuerysetEqual(res.context['table'].data,
 
111
                                 expected,
 
112
                                 lambda obj: obj.name)
147
113
 
148
114
    def test_upload_index(self):
149
115
        res = self.client.get(reverse('horizon:nova:containers:object_upload',
150
 
                                      args=[self.CONTAINER_NAME]))
151
 
 
 
116
                                      args=[self.containers.first().name]))
152
117
        self.assertTemplateUsed(res, 'nova/objects/upload.html')
153
118
 
154
119
    def test_upload(self):
 
120
        container = self.containers.first()
 
121
        obj = self.objects.first()
155
122
        OBJECT_DATA = 'objectData'
156
 
        OBJECT_FILE = tempfile.TemporaryFile()
157
 
        OBJECT_FILE.write(OBJECT_DATA)
158
 
        OBJECT_FILE.flush()
159
 
        OBJECT_FILE.seek(0)
160
 
        OBJECT_NAME = 'objectName'
161
123
 
162
 
        formData = {'method': 'UploadObject',
163
 
                    'container_name': self.CONTAINER_NAME,
164
 
                    'name': OBJECT_NAME,
165
 
                    'object_file': OBJECT_FILE}
 
124
        temp_file = tempfile.TemporaryFile()
 
125
        temp_file.write(OBJECT_DATA)
 
126
        temp_file.flush()
 
127
        temp_file.seek(0)
166
128
 
167
129
        self.mox.StubOutWithMock(api, 'swift_upload_object')
168
130
        api.swift_upload_object(IsA(http.HttpRequest),
169
 
                                unicode(self.CONTAINER_NAME),
170
 
                                unicode(OBJECT_NAME),
171
 
                                OBJECT_DATA).AndReturn(self.swift_objects[0])
172
 
 
 
131
                                container.name,
 
132
                                obj.name,
 
133
                                OBJECT_DATA).AndReturn(obj)
 
134
        self.mox.StubOutWithMock(obj, 'sync_metadata')
 
135
        obj.sync_metadata()
173
136
        self.mox.ReplayAll()
174
 
 
175
 
        res = self.client.get(reverse('horizon:nova:containers:object_upload',
176
 
                                       args=[self.CONTAINER_NAME]))
177
 
 
 
137
        upload_url = reverse('horizon:nova:containers:object_upload',
 
138
                             args=[container.name])
 
139
        res = self.client.get(upload_url)
178
140
        self.assertContains(res, 'enctype="multipart/form-data"')
179
141
 
180
 
        res = self.client.post(reverse('horizon:nova:containers:object_upload',
181
 
                                       args=[self.CONTAINER_NAME]),
182
 
                               formData)
 
142
        formData = {'method': forms.UploadObject.__name__,
 
143
                    'container_name': container.name,
 
144
                    'name': obj.name,
 
145
                    'object_file': temp_file}
 
146
        res = self.client.post(upload_url, formData)
183
147
 
184
 
        self.assertRedirectsNoFollow(res,
185
 
                            reverse('horizon:nova:containers:object_index',
186
 
                                    args=[self.CONTAINER_NAME]))
 
148
        index_url = reverse('horizon:nova:containers:object_index',
 
149
                            args=[container.name])
 
150
        self.assertRedirectsNoFollow(res, index_url)
187
151
 
188
152
    def test_delete(self):
 
153
        container = self.containers.first()
 
154
        obj = self.objects.first()
 
155
        index_url = reverse('horizon:nova:containers:object_index',
 
156
                            args=[container.name])
189
157
        self.mox.StubOutWithMock(api, 'swift_delete_object')
190
 
        api.swift_delete_object(
191
 
                IsA(http.HttpRequest),
192
 
                self.CONTAINER_NAME, self.swift_objects[0].name)
193
 
 
 
158
        api.swift_delete_object(IsA(http.HttpRequest),
 
159
                                container.name,
 
160
                                obj.name)
194
161
        self.mox.ReplayAll()
195
162
 
196
 
        OBJECT_INDEX_URL = reverse('horizon:nova:containers:object_index',
197
 
                                   args=[self.CONTAINER_NAME])
198
 
        action_string = "objects__delete__%s" % self.swift_objects[0].name
 
163
        action_string = "objects__delete__%s" % obj.name
199
164
        form_data = {"action": action_string}
200
 
        req = self.factory.post(OBJECT_INDEX_URL, form_data)
201
 
        kwargs = {"container_name": self.CONTAINER_NAME}
202
 
        table = ObjectsTable(req, self.swift_objects, **kwargs)
 
165
        req = self.factory.post(index_url, form_data)
 
166
        kwargs = {"container_name": container.name}
 
167
        table = ObjectsTable(req, self.objects.list(), **kwargs)
203
168
        handled = table.maybe_handle()
204
 
 
205
 
        self.assertEqual(handled['location'], OBJECT_INDEX_URL)
 
169
        self.assertEqual(handled['location'], index_url)
206
170
 
207
171
    def test_download(self):
 
172
        container = self.containers.first()
 
173
        obj = self.objects.first()
208
174
        OBJECT_DATA = 'objectData'
209
 
        OBJECT_NAME = 'objectName'
210
175
 
211
176
        self.mox.StubOutWithMock(api, 'swift_get_object_data')
212
177
        self.mox.StubOutWithMock(api.swift, 'swift_get_object')
213
 
 
214
178
        api.swift.swift_get_object(IsA(http.HttpRequest),
215
 
                                  unicode(self.CONTAINER_NAME),
216
 
                                  unicode(OBJECT_NAME)) \
217
 
                                  .AndReturn(self.swift_objects[0])
 
179
                                   container.name,
 
180
                                   obj.name).AndReturn(obj)
218
181
        api.swift_get_object_data(IsA(http.HttpRequest),
219
 
                                  unicode(self.CONTAINER_NAME),
220
 
                                  unicode(OBJECT_NAME)).AndReturn(OBJECT_DATA)
221
 
 
 
182
                                  container.name,
 
183
                                  obj.name).AndReturn(OBJECT_DATA)
222
184
        self.mox.ReplayAll()
223
185
 
224
 
        res = self.client.get(reverse(
225
 
                            'horizon:nova:containers:object_download',
226
 
                            args=[self.CONTAINER_NAME, OBJECT_NAME]))
227
 
 
 
186
        download_url = reverse('horizon:nova:containers:object_download',
 
187
                               args=[container.name, obj.name])
 
188
        res = self.client.get(download_url)
228
189
        self.assertEqual(res.content, OBJECT_DATA)
229
190
        self.assertTrue(res.has_header('Content-Disposition'))
230
191
 
231
192
    def test_copy_index(self):
232
 
        OBJECT_NAME = 'objectName'
233
 
 
234
 
        container = self.mox.CreateMock(api.Container)
235
 
        container.name = self.CONTAINER_NAME
236
 
 
237
193
        self.mox.StubOutWithMock(api, 'swift_get_containers')
238
 
        api.swift_get_containers(
239
 
                IsA(http.HttpRequest)).AndReturn(([container], False))
240
 
 
 
194
        ret = (self.containers.list(), False)
 
195
        api.swift_get_containers(IsA(http.HttpRequest)).AndReturn(ret)
241
196
        self.mox.ReplayAll()
242
197
 
243
198
        res = self.client.get(reverse('horizon:nova:containers:object_copy',
244
 
                                      args=[self.CONTAINER_NAME,
245
 
                                            OBJECT_NAME]))
246
 
 
 
199
                                      args=[self.containers.first().name,
 
200
                                            self.objects.first().name]))
247
201
        self.assertTemplateUsed(res, 'nova/objects/copy.html')
248
202
 
249
203
    def test_copy(self):
250
 
        NEW_CONTAINER_NAME = self.CONTAINER_NAME
251
 
        NEW_OBJECT_NAME = 'newObjectName'
252
 
        ORIG_CONTAINER_NAME = 'origContainerName'
253
 
        ORIG_OBJECT_NAME = 'origObjectName'
254
 
 
255
 
        formData = {'method': 'CopyObject',
256
 
                    'new_container_name': NEW_CONTAINER_NAME,
257
 
                    'new_object_name': NEW_OBJECT_NAME,
258
 
                    'orig_container_name': ORIG_CONTAINER_NAME,
259
 
                    'orig_object_name': ORIG_OBJECT_NAME}
260
 
 
261
 
        container = self.mox.CreateMock(api.Container)
262
 
        container.name = self.CONTAINER_NAME
 
204
        container_1 = self.containers.get(name="container_one")
 
205
        container_2 = self.containers.get(name="container_two")
 
206
        obj = self.objects.first()
263
207
 
264
208
        self.mox.StubOutWithMock(api, 'swift_get_containers')
265
 
        api.swift_get_containers(
266
 
                IsA(http.HttpRequest)).AndReturn(([container], False))
267
 
 
268
209
        self.mox.StubOutWithMock(api, 'swift_copy_object')
 
210
        ret = (self.containers.list(), False)
 
211
        api.swift_get_containers(IsA(http.HttpRequest)).AndReturn(ret)
269
212
        api.swift_copy_object(IsA(http.HttpRequest),
270
 
                              ORIG_CONTAINER_NAME,
271
 
                              ORIG_OBJECT_NAME,
272
 
                              NEW_CONTAINER_NAME,
273
 
                              NEW_OBJECT_NAME)
274
 
 
 
213
                              container_1.name,
 
214
                              obj.name,
 
215
                              container_2.name,
 
216
                              obj.name)
275
217
        self.mox.ReplayAll()
276
218
 
277
 
        res = self.client.post(reverse('horizon:nova:containers:object_copy',
278
 
                                       args=[ORIG_CONTAINER_NAME,
279
 
                                             ORIG_OBJECT_NAME]),
280
 
                              formData)
281
 
 
282
 
        self.assertRedirectsNoFollow(res,
283
 
                            reverse('horizon:nova:containers:object_index',
284
 
                                    args=[NEW_CONTAINER_NAME]))
 
219
        formData = {'method': forms.CopyObject.__name__,
 
220
                    'new_container_name': container_2.name,
 
221
                    'new_object_name': obj.name,
 
222
                    'orig_container_name': container_1.name,
 
223
                    'orig_object_name': obj.name}
 
224
        copy_url = reverse('horizon:nova:containers:object_copy',
 
225
                           args=[container_1.name, obj.name])
 
226
        res = self.client.post(copy_url, formData)
 
227
        index_url = reverse('horizon:nova:containers:object_index',
 
228
                            args=[container_2.name])
 
229
        self.assertRedirectsNoFollow(res, index_url)