262 lines
10 KiB
Python
262 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___repr__(self):
|
|
self.instance.name = "instance-1"
|
|
self.assertEqual('<Instance: instance-1>', self.instance.__repr__())
|
|
|
|
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)
|