← Back to branch summary

~ubuntu-branches/ubuntu/utopic/horizon/utopic

« back to all changes in this revision

Viewing changes to openstack_dashboard/dashboards/project/databases/tests.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2014-07-25 11:39:09 UTC
  • mfrom: (1.1.42)
  • Revision ID: package-import@ubuntu.com-20140725113909-b8920pdy87itn1ro
Tags: 1:2014.2~b2-0ubuntu1
* New upstream release.
* debian/patches/ubuntu_settings.patch: Refresed
* debian/patches/fix-dashboard-manage.patch: Refreshed
* debian/patches/fix-dashboard-django-wsgi.patch: Refreshed

Show diffs side-by-side

added added

removed removed

Lines of Context:
openstack_dashboard/dashboards/project/databases/tests.py
81
81
    def test_index_pagination(self):
82
82
        # Mock database instances
83
83
        databases = self.databases.list()
84
 
        last_record = databases[-1]
85
 
        databases = common.Paginated(databases,
86
 
            next_marker="foo")
 
84
        last_record = databases[1]
 
85
        databases = common.Paginated(databases, next_marker="foo")
87
86
        api.trove.instance_list(IsA(http.HttpRequest), marker=None)\
88
87
            .AndReturn(databases)
89
88
        # Mock flavors
115
114
        self.assertMessageCount(res, error=1)
116
115
 
117
116
    @test.create_stubs({
118
 
        api.trove: ('flavor_list', 'backup_list',)})
 
117
        api.trove: ('flavor_list', 'backup_list',
 
118
                        'datastore_list', 'datastore_version_list')})
119
119
    def test_launch_instance(self):
120
120
        api.trove.flavor_list(IsA(http.HttpRequest))\
121
121
            .AndReturn(self.flavors.list())
122
122
        api.trove.backup_list(IsA(http.HttpRequest))\
123
123
            .AndReturn(self.database_backups.list())
124
 
 
 
124
        # Mock datastores
 
125
        api.trove.datastore_list(IsA(http.HttpRequest))\
 
126
            .AndReturn(self.datastores.list())
 
127
        # Mock datastore versions
 
128
        api.trove.datastore_version_list(IsA(http.HttpRequest),
 
129
            IsA(str)).AndReturn(self.datastore_versions.list())
125
130
        self.mox.ReplayAll()
126
131
        res = self.client.get(LAUNCH_URL)
127
132
        self.assertTemplateUsed(res, 'project/databases/launch.html')
128
133
 
129
134
    @test.create_stubs({
130
 
        api.trove: ('flavor_list', 'backup_list', 'instance_create',)})
 
135
        api.trove: ('flavor_list', 'backup_list', 'instance_create',
 
136
                    'datastore_list', 'datastore_version_list'),
 
137
        api.neutron: ('network_list',)})
131
138
    def test_create_simple_instance(self):
132
 
        api.trove.flavor_list(IsA(http.HttpRequest))\
133
 
            .AndReturn(self.flavors.list())
134
 
        api.trove.backup_list(IsA(http.HttpRequest))\
135
 
            .AndReturn(self.database_backups.list())
 
139
        api.trove.flavor_list(IsA(http.HttpRequest)).AndReturn(
 
140
            self.flavors.list())
 
141
 
 
142
        api.trove.backup_list(IsA(http.HttpRequest)).AndReturn(
 
143
            self.database_backups.list())
 
144
 
 
145
        # Mock datastores
 
146
        api.trove.datastore_list(IsA(http.HttpRequest))\
 
147
            .AndReturn(self.datastores.list())
 
148
 
 
149
        # Mock datastore versions
 
150
        api.trove.datastore_version_list(IsA(http.HttpRequest),
 
151
            IsA(str)).AndReturn(self.datastore_versions.list())
 
152
 
 
153
        api.neutron.network_list(IsA(http.HttpRequest),
 
154
                                 tenant_id=self.tenant.id,
 
155
                                 shared=False).AndReturn(
 
156
                                     self.networks.list()[:1])
 
157
 
 
158
        api.neutron.network_list(IsA(http.HttpRequest),
 
159
                                 shared=True).AndReturn(
 
160
                                     self.networks.list()[1:])
 
161
 
 
162
        nics = [{"net-id": self.networks.first().id, "v4-fixed-ip": ''}]
136
163
 
137
164
        # Actual create database call
138
165
        api.trove.instance_create(
141
168
            IsA(int),
142
169
            IsA(unicode),
143
170
            databases=None,
 
171
            datastore=IsA(unicode),
 
172
            datastore_version=IsA(unicode),
144
173
            restore_point=None,
145
 
            users=None).AndReturn(self.databases.first())
 
174
            users=None,
 
175
            nics=nics).AndReturn(self.databases.first())
146
176
 
147
177
        self.mox.ReplayAll()
148
178
        post = {
149
179
            'name': "MyDB",
150
180
            'volume': '1',
151
181
            'flavor': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
 
182
            'network': self.networks.first().id,
 
183
            'datastore': 'mysql,5.5'
152
184
        }
153
185
 
154
186
        res = self.client.post(LAUNCH_URL, post)
155
187
        self.assertRedirectsNoFollow(res, INDEX_URL)
156
188
 
157
189
    @test.create_stubs({
158
 
        api.trove: ('flavor_list', 'backup_list', 'instance_create',)})
 
190
        api.trove: ('flavor_list', 'backup_list', 'instance_create',
 
191
                    'datastore_list', 'datastore_version_list'),
 
192
        api.neutron: ('network_list',)})
159
193
    def test_create_simple_instance_exception(self):
160
194
        trove_exception = self.exceptions.nova
161
 
        api.trove.flavor_list(IsA(http.HttpRequest))\
162
 
            .AndReturn(self.flavors.list())
163
 
        api.trove.backup_list(IsA(http.HttpRequest))\
164
 
            .AndReturn(self.database_backups.list())
 
195
        api.trove.flavor_list(IsA(http.HttpRequest)).AndReturn(
 
196
            self.flavors.list())
 
197
 
 
198
        api.trove.backup_list(IsA(http.HttpRequest)).AndReturn(
 
199
            self.database_backups.list())
 
200
 
 
201
        # Mock datastores
 
202
        api.trove.datastore_list(IsA(http.HttpRequest))\
 
203
            .AndReturn(self.datastores.list())
 
204
 
 
205
        # Mock datastore versions
 
206
        api.trove.datastore_version_list(IsA(http.HttpRequest),
 
207
            IsA(str)).AndReturn(self.datastore_versions.list())
 
208
 
 
209
        api.neutron.network_list(IsA(http.HttpRequest),
 
210
                                 tenant_id=self.tenant.id,
 
211
                                 shared=False).AndReturn(
 
212
                                     self.networks.list()[:1])
 
213
 
 
214
        api.neutron.network_list(IsA(http.HttpRequest),
 
215
                                 shared=True).AndReturn(
 
216
                                     self.networks.list()[1:])
 
217
 
 
218
        nics = [{"net-id": self.networks.first().id, "v4-fixed-ip": ''}]
165
219
 
166
220
        # Actual create database call
167
221
        api.trove.instance_create(
170
224
            IsA(int),
171
225
            IsA(unicode),
172
226
            databases=None,
 
227
            datastore=IsA(unicode),
 
228
            datastore_version=IsA(unicode),
173
229
            restore_point=None,
174
 
            users=None).AndRaise(trove_exception)
 
230
            users=None,
 
231
            nics=nics).AndRaise(trove_exception)
175
232
 
176
233
        self.mox.ReplayAll()
177
234
        post = {
178
235
            'name': "MyDB",
179
236
            'volume': '1',
180
237
            'flavor': 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa',
 
238
            'network': self.networks.first().id,
 
239
            'datastore': 'mysql,5.5'
181
240
        }
182
241
 
183
242
        res = self.client.post(LAUNCH_URL, post)
206
265
    def test_details_with_hostname(self):
207
266
        database = self.databases.list()[1]
208
267
        self._test_details(database, with_designate=True)
 
268
 
 
269
    @test.create_stubs(
 
270
        {api.trove: ('instance_get', 'flavor_get', 'users_list',
 
271
                     'user_list_access', 'user_delete')})
 
272
    def test_user_delete(self):
 
273
        database = self.databases.first()
 
274
        user = self.database_users.first()
 
275
        user_db = self.database_user_dbs.first()
 
276
 
 
277
        database_id = database.id
 
278
        # Instead of using the user's ID, the api uses the user's name. BOOO!
 
279
        user_id = user.name
 
280
 
 
281
        # views.py: DetailView.get_data
 
282
        api.trove.instance_get(IsA(http.HttpRequest), IsA(unicode))\
 
283
            .AndReturn(database)
 
284
        api.trove.flavor_get(IsA(http.HttpRequest), IsA(str))\
 
285
            .AndReturn(self.flavors.first())
 
286
 
 
287
        # tabs.py: UserTab.get_user_data
 
288
        api.trove.users_list(IsA(http.HttpRequest),
 
289
                             database_id).AndReturn([user])
 
290
        api.trove.user_list_access(IsA(http.HttpRequest),
 
291
                                   database_id,
 
292
                                   user_id).AndReturn([user_db])
 
293
 
 
294
        # tables.py: DeleteUser.delete
 
295
        api.trove.user_delete(IsA(http.HttpRequest),
 
296
                              database_id,
 
297
                              user_id).AndReturn(None)
 
298
 
 
299
        self.mox.ReplayAll()
 
300
 
 
301
        details_url = reverse('horizon:project:databases:detail',
 
302
                              args=[database_id])
 
303
        url = details_url + '?tab=instance_details__users_tab'
 
304
        action_string = u"users__delete__%s" % user_id
 
305
        form_data = {'action': action_string}
 
306
        res = self.client.post(url, form_data)
 
307
        self.assertRedirectsNoFollow(res, url)
 
308
 
 
309
    @test.create_stubs(
 
310
        {api.trove: ('instance_get', 'instance_resize_volume' )})
 
311
    def test_resize_volume(self):
 
312
        database = self.databases.first()
 
313
        database_id = database.id
 
314
        database_size = database.volume.get('size')
 
315
 
 
316
        # views.py: DetailView.get_data
 
317
        api.trove.instance_get(IsA(http.HttpRequest), IsA(unicode))\
 
318
            .AndReturn(database)
 
319
 
 
320
        # forms.py: ResizeVolumeForm.handle
 
321
        api.trove.instance_resize_volume(IsA(http.HttpRequest),
 
322
                              database_id, IsA(int)).AndReturn(None)
 
323
 
 
324
        self.mox.ReplayAll()
 
325
        url = reverse('horizon:project:databases:resize_volume',
 
326
                              args=[database_id])
 
327
        post = {
 
328
            'instance_id': database_id,
 
329
            'orig_size': database_size,
 
330
            'new_size': database_size + 1
 
331
        }
 
332
        res = self.client.post(url, post)
 
333
        self.assertNoFormErrors(res)
 
334
        self.assertRedirectsNoFollow(res, INDEX_URL)
 
335
 
 
336
    @test.create_stubs(
 
337
        {api.trove: ('instance_get', 'instance_resize_volume' )})
 
338
    def test_resize_volume_bad_value(self):
 
339
        database = self.databases.first()
 
340
        database_id = database.id
 
341
        database_size = database.volume.get('size')
 
342
 
 
343
        # views.py: DetailView.get_data
 
344
        api.trove.instance_get(IsA(http.HttpRequest), IsA(unicode))\
 
345
            .AndReturn(database)
 
346
 
 
347
        self.mox.ReplayAll()
 
348
        url = reverse('horizon:project:databases:resize_volume',
 
349
                              args=[database_id])
 
350
        post = {
 
351
            'instance_id': database_id,
 
352
            'orig_size': database_size,
 
353
            'new_size': database_size
 
354
        }
 
355
        res = self.client.post(url, post)
 
356
        self.assertContains(res,
 
357
             "New size for volume must be greater than current size.")
 
358