ea0e472edd
Mistral gets confused by Trove's (aguably wrong) inclusion of a member called 'items' in the Pagenated object that Trove returns as the result of 'list' client methods. This change changes Pagenated to inherit from the 'list' class so that the items method is not required (and has the additional benefit of just generally being a better implementation of a list type result). Change-Id: I683120451f69f07f131e6fa422c082f85735b196 Closes-bug: 1585705 Depends-On: Id674ae57bfcdc5e09bde1e323a614b3a03a7cad3
258 lines
10 KiB
Python
258 lines
10 KiB
Python
# Copyright 2011 OpenStack Foundation
|
|
# Copyright 2013 Rackspace Hosting
|
|
# Copyright 2013 Hewlett-Packard Development Company, L.P.
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import mock
|
|
import testtools
|
|
|
|
from troveclient import base
|
|
from troveclient.v1 import instances
|
|
|
|
"""
|
|
Unit tests for instances.py
|
|
"""
|
|
|
|
|
|
class InstanceTest(testtools.TestCase):
|
|
|
|
def setUp(self):
|
|
super(InstanceTest, self).setUp()
|
|
self.orig__init = instances.Instance.__init__
|
|
instances.Instance.__init__ = mock.Mock(return_value=None)
|
|
self.instance = instances.Instance()
|
|
self.instance.manager = mock.Mock()
|
|
|
|
def tearDown(self):
|
|
super(InstanceTest, self).tearDown()
|
|
instances.Instance.__init__ = self.orig__init
|
|
|
|
def test_list_databases(self):
|
|
db_list = ['database1', 'database2']
|
|
self.instance.manager.databases = mock.Mock()
|
|
self.instance.manager.databases.list = mock.Mock(return_value=db_list)
|
|
self.assertEqual(db_list, self.instance.list_databases())
|
|
|
|
def test_delete(self):
|
|
db_delete_mock = mock.Mock(return_value=None)
|
|
self.instance.manager.delete = db_delete_mock
|
|
self.instance.delete()
|
|
self.assertEqual(1, db_delete_mock.call_count)
|
|
|
|
def test_restart(self):
|
|
db_restart_mock = mock.Mock(return_value=None)
|
|
self.instance.manager.restart = db_restart_mock
|
|
self.instance.id = 1
|
|
self.instance.restart()
|
|
self.assertEqual(1, db_restart_mock.call_count)
|
|
|
|
def test_detach_replica(self):
|
|
db_detach_mock = mock.Mock(return_value=None)
|
|
self.instance.manager.edit = db_detach_mock
|
|
self.instance.id = 1
|
|
self.instance.detach_replica()
|
|
self.assertEqual(1, db_detach_mock.call_count)
|
|
|
|
|
|
class InstancesTest(testtools.TestCase):
|
|
|
|
def setUp(self):
|
|
super(InstancesTest, self).setUp()
|
|
self.orig__init = instances.Instances.__init__
|
|
instances.Instances.__init__ = mock.Mock(return_value=None)
|
|
self.instances = instances.Instances()
|
|
self.instances.api = mock.Mock()
|
|
self.instances.api.client = mock.Mock()
|
|
self.instances.resource_class = mock.Mock(return_value="instance-1")
|
|
|
|
self.instance_with_id = mock.Mock()
|
|
self.instance_with_id.id = 215
|
|
|
|
def tearDown(self):
|
|
super(InstancesTest, self).tearDown()
|
|
instances.Instances.__init__ = self.orig__init
|
|
|
|
@mock.patch('warnings.warn')
|
|
def test_create(self, mock_warn):
|
|
def side_effect_func(path, body, inst):
|
|
return path, body, inst
|
|
|
|
self.instances._create = mock.Mock(side_effect=side_effect_func)
|
|
nics = [{'net-id': '000'}]
|
|
p, b, i = self.instances.create("test-name", 103, "test-volume",
|
|
['db1', 'db2'], ['u1', 'u2'],
|
|
datastore="datastore",
|
|
datastore_version="datastore-version",
|
|
nics=nics, slave_of='test',
|
|
modules=['mod_id'])
|
|
self.assertEqual("/instances", p)
|
|
self.assertEqual("instance", i)
|
|
self.assertEqual(['db1', 'db2'], b["instance"]["databases"])
|
|
self.assertEqual(['u1', 'u2'], b["instance"]["users"])
|
|
self.assertEqual("test-name", b["instance"]["name"])
|
|
self.assertEqual("test-volume", b["instance"]["volume"])
|
|
self.assertEqual("datastore", b["instance"]["datastore"]["type"])
|
|
self.assertEqual("datastore-version",
|
|
b["instance"]["datastore"]["version"])
|
|
self.assertEqual(nics, b["instance"]["nics"])
|
|
self.assertEqual(103, b["instance"]["flavorRef"])
|
|
# Assert that slave_of is not used and if specified, there is a warning
|
|
# and it's value is used for replica_of.
|
|
self.assertEqual('test', b['instance']['replica_of'])
|
|
self.assertNotIn('slave_of', b['instance'])
|
|
self.assertTrue(mock_warn.called)
|
|
self.assertEqual([{'id': 'mod_id'}], b["instance"]["modules"])
|
|
|
|
def test_list(self):
|
|
page_mock = mock.Mock()
|
|
self.instances._paginated = page_mock
|
|
limit = "test-limit"
|
|
marker = "test-marker"
|
|
include_clustered = {'include_clustered': False}
|
|
self.instances.list(limit, marker)
|
|
page_mock.assert_called_with("/instances", "instances", limit, marker,
|
|
include_clustered)
|
|
|
|
def test_get(self):
|
|
def side_effect_func(path, inst):
|
|
return path, inst
|
|
|
|
self.instances._get = mock.Mock(side_effect=side_effect_func)
|
|
self.assertEqual(('/instances/instance1', 'instance'),
|
|
self.instances.get('instance1'))
|
|
|
|
def test_delete(self):
|
|
resp = mock.Mock()
|
|
resp.status_code = 200
|
|
body = None
|
|
self.instances.api.client.delete = mock.Mock(return_value=(resp, body))
|
|
self.instances.delete('instance1')
|
|
self.instances.delete(self.instance_with_id)
|
|
resp.status_code = 500
|
|
self.assertRaises(Exception, self.instances.delete, 'instance1')
|
|
|
|
def test__action(self):
|
|
body = mock.Mock()
|
|
resp = mock.Mock()
|
|
resp.status_code = 200
|
|
self.instances.api.client.post = mock.Mock(return_value=(resp, body))
|
|
self.assertEqual('instance-1', self.instances._action(1, body))
|
|
|
|
self.instances.api.client.post = mock.Mock(return_value=(resp, None))
|
|
self.assertIsNone(self.instances._action(1, body))
|
|
|
|
def _set_action_mock(self):
|
|
def side_effect_func(instance, body):
|
|
self._instance_id = base.getid(instance)
|
|
self._body = body
|
|
|
|
self._instance_id = None
|
|
self._body = None
|
|
self.instances._action = mock.Mock(side_effect=side_effect_func)
|
|
|
|
def _test_resize_volume(self, instance, id):
|
|
self._set_action_mock()
|
|
self.instances.resize_volume(instance, 1024)
|
|
self.assertEqual(id, self._instance_id)
|
|
self.assertEqual({"resize": {"volume": {"size": 1024}}}, self._body)
|
|
|
|
def test_resize_volume_with_id(self):
|
|
self._test_resize_volume(152, 152)
|
|
|
|
def test_resize_volume_with_obj(self):
|
|
self._test_resize_volume(self.instance_with_id,
|
|
self.instance_with_id.id)
|
|
|
|
def _test_resize_instance(self, instance, id):
|
|
self._set_action_mock()
|
|
self.instances.resize_instance(instance, 103)
|
|
self.assertEqual(id, self._instance_id)
|
|
self.assertEqual({"resize": {"flavorRef": 103}}, self._body)
|
|
|
|
def test_resize_instance_with_id(self):
|
|
self._test_resize_instance(4725, 4725)
|
|
|
|
def test_resize_instance_with_obj(self):
|
|
self._test_resize_instance(self.instance_with_id,
|
|
self.instance_with_id.id)
|
|
|
|
def _test_restart(self, instance, id):
|
|
self._set_action_mock()
|
|
self.instances.restart(instance)
|
|
self.assertEqual(id, self._instance_id)
|
|
self.assertEqual({'restart': {}}, self._body)
|
|
|
|
def test_restart_with_id(self):
|
|
self._test_restart(253, 253)
|
|
|
|
def test_restart_with_obj(self):
|
|
self._test_restart(self.instance_with_id, self.instance_with_id.id)
|
|
|
|
def test_modify(self):
|
|
resp = mock.Mock()
|
|
resp.status_code = 200
|
|
body = None
|
|
self.instances.api.client.put = mock.Mock(return_value=(resp, body))
|
|
self.instances.modify(123)
|
|
self.instances.modify(123, 321)
|
|
self.instances.modify(self.instance_with_id)
|
|
self.instances.modify(self.instance_with_id, 123)
|
|
resp.status_code = 500
|
|
self.assertRaises(Exception, self.instances.modify, 'instance1')
|
|
|
|
def test_edit(self):
|
|
resp = mock.Mock()
|
|
resp.status_code = 204
|
|
|
|
def fake_patch(url, body):
|
|
# Make sure we never pass slave_of to the API.
|
|
self.assertIn('instance', body)
|
|
self.assertNotIn('slave_of', body['instance'])
|
|
return resp, None
|
|
|
|
self.instances.api.client.patch = mock.Mock(side_effect=fake_patch)
|
|
self.instances.edit(123)
|
|
self.instances.edit(123, 321)
|
|
self.instances.edit(123, 321, 'name-1234')
|
|
self.instances.edit(123, 321, 'name-1234', True)
|
|
self.instances.edit(self.instance_with_id)
|
|
self.instances.edit(self.instance_with_id, 123)
|
|
self.instances.edit(self.instance_with_id, 123, 'name-1234')
|
|
self.instances.edit(self.instance_with_id, 123, 'name-1234', True)
|
|
resp.status_code = 500
|
|
self.assertRaises(Exception, self.instances.edit, 'instance1')
|
|
|
|
def test_configuration(self):
|
|
def side_effect_func(path, inst):
|
|
return path, inst
|
|
|
|
self.instances._get = mock.Mock(side_effect=side_effect_func)
|
|
self.assertEqual(('/instances/instance1/configuration', 'instance'),
|
|
self.instances.configuration('instance1'))
|
|
|
|
|
|
class InstanceStatusTest(testtools.TestCase):
|
|
|
|
def test_constants(self):
|
|
self.assertEqual("ACTIVE", instances.InstanceStatus.ACTIVE)
|
|
self.assertEqual("BLOCKED", instances.InstanceStatus.BLOCKED)
|
|
self.assertEqual("BUILD", instances.InstanceStatus.BUILD)
|
|
self.assertEqual("FAILED", instances.InstanceStatus.FAILED)
|
|
self.assertEqual("REBOOT", instances.InstanceStatus.REBOOT)
|
|
self.assertEqual("RESIZE", instances.InstanceStatus.RESIZE)
|
|
self.assertEqual("SHUTDOWN", instances.InstanceStatus.SHUTDOWN)
|
|
self.assertEqual("RESTART_REQUIRED",
|
|
instances.InstanceStatus.RESTART_REQUIRED)
|