def setUp(self): util.init_db() self.fake_tenantid = 'fake_fore_1231242345' self.fake_context = fake() self.fake_context.limit = 1000 self.fake_context.is_admin = False self.fake_context.marker = None self.fake_context['tenant'] = self.fake_tenantid self.fake_environ = {wsgi.CONTEXT_KEY : self.fake_context} self.fake_request = fake() self.fake_request.url = "http://fore.com/***" self.fake_request.environ = self.fake_environ self.cnf_controller = conf_service.ConfigurationsController() self.para_controller = conf_service.ParametersController() self.base_body = { "configuration": { "values": {}, "name": "test", "description":"desc....", "datastore": { "type": "test_type", "version": "test_version" } } } self.fake_dsname = "test_type" self.fake_dsversion = "test_version" ds_models.update_datastore(self.fake_dsname) ds = ds_models.Datastore.load(self.fake_dsname) ds_models.update_datastore_version(ds.name, self.fake_dsversion, "mysql", "None","None", '1','1')
def test_relocate_master(self): pass master_id = "master_id" slave_id = "slave_id" instance = fake() def get_guest(): return API(self.context,master_id) instance.get_guest = get_guest when(FreshInstanceTasks).load(any(),any()).thenReturn(instance) mStatus = {"file":"test_file","position":"1"} when(API).ksc_show_master_status().thenReturn(mStatus) group_item = fake() group_item.group_id = 1 when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item) when(FreshInstanceTasks)._get_instance_ip(any()).thenReturn("master_host") when(FreshInstanceTasks)._gen_rpl_user_password(any()).thenReturn("repl_password") when(API).ksc_relocate_master(master_host=any(), repl_user=any(), repl_password=any(), master_log_file=any(), master_log_pos=any()).thenReturn(None) self.instance._relocate_master(master_id,slave_id)
def test_restore_success(self): _bk = self._create_restore_strategy() prepare_process = fake() prepare_process.pid = "pid" def _terminate(): pass prepare_process.terminate = _terminate prepare_process.stderr = self._read_fake_output("prepare_ok") when(_bk)._pre_restore().thenReturn(None) when(_bk)._post_restore().thenReturn(None) when(subprocess).Popen(_bk.prepare_cmd, shell=True, stdin=subprocess.PIPE, stderr=subprocess.PIPE).thenReturn(prepare_process) restore_process = fake() restore_process.pid = "pid" def _terminate(): pass restore_process.terminate = _terminate restore_process.stderr = self._read_fake_output("prepare_ok") when(subprocess).Popen(_bk.restore_cmd, shell=True, stdin=subprocess.PIPE, stderr=subprocess.PIPE).thenReturn(restore_process) self.assertFalse(_bk.restore())
def test_failover_standby(self): master = fake() master.instance_id = "master_instance_id" master.id = "master_id" when(InstanceGroupItem).get_by_gid_type(any(), any(),any()).thenReturn([master]) when(InstanceGroupItem).update_type(context=any(), item_id=any(), type=any()).thenReturn(None) group_item = fake() group_item.group_id = 1 group_item.id = 1 when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item) when(FreshInstanceTasks)._relocate_master(master_id=any(), slave_id=any()).thenReturn(None) pass old_group_item = fake() old_group_item.instance_id = "old_instance_id" old_group_item.group_id = "old_group_id" old_group_item.id = "old_group_item_id" self.instance._failover_standby(old_group_item) verify(InstanceGroupItem,times=2).update_type(context=any(), item_id=any(), type=any()) verify(FreshInstanceTasks,times=1)._relocate_master(master_id=any(), slave_id=any())
def test_failover_rr(self): master = fake() master.instance_id = "master_instance_id" master.id = "master_id" when(InstanceGroupItem).get_by_gid_type(any(), any(),any()).thenReturn([master]) when(InstanceGroupItem).update_type(context=any(), item_id=any(), type=any()).thenReturn(None) group_item = fake() group_item.group_id = 1 group_item.id = 1 when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item) when(FreshInstanceTasks)._relocate_master(master_id=any(), slave_id=any()).thenReturn(None) CONF.trove_vip_support = True when(InstanceVip).get_by_instance_id(any(),any()).thenReturn("localhost") when(InstanceVip).allocate(any(),instance_id=any(),vip=any()).thenReturn("localhost") pass old_group_item = fake() old_group_item.instance_id = "old_instance_id" old_group_item.group_id = "old_group_id" old_group_item.id = "old_group_item_id" self.instance._failover_rr(old_group_item) verify(InstanceGroupItem,times=2).update_type(context=any(), item_id=any(), type=any()) verify(FreshInstanceTasks,times=1)._relocate_master(master_id=any(), slave_id=any()) verify(InstanceVip).get_by_instance_id(any(),any()) verify(InstanceVip).allocate(any(),instance_id=any(),vip=any())
def test_failover_create_instance(self): when(FreshInstanceTasks)._waite_relay_finished(any()).thenReturn(None) group_item = fake() group_item.group_id = 1 group_item.id = 1 group_item.type = DBInstanceType.MASTER when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item) when(FreshInstanceTasks)._failover_master(any()).thenReturn(None) when(FreshInstanceTasks)._get_ignore_hosts(any()).thenReturn(None) when(FreshInstanceTasks)._create_server_volume_individually(any(),any(),any(),any(),any(),any()).thenReturn((None,None)) config = fake() config.config_contents = "" when(FreshInstanceTasks)._render_config(any(), any(), instance_id=any()).thenReturn(config) when(FreshInstanceTasks)._guest_prepare(any(), any(), any(), any(), any(), any(), any()) when(FreshInstanceTasks).update_db(task_status=any()).thenReturn(None) when(utils).poll_until(any(), sleep_time=any(), time_out=any()).thenRaise(Exception("mm")) when(FreshInstanceTasks)._failover_master(any()).thenReturn(None) when(FreshInstanceTasks).send_usage_event(any(), instance_size=any()).thenReturn(None) when(FreshInstanceTasks).failover_release_resource(any()).thenReturn(None) item = fake() item.id = "123" when(InstanceGroupItem).get_by_gid_type(any(), any(),any()).thenReturn(item) when(InstanceGroupItem).update_type(context=any(), item_id=any(),type=any()).thenReturn(None) flavor = {"ram":"1000","id":"1"} image_id ="image_id" service_type = "service_type" volume_size = "volume_size" security_groups = "security_groups" backup_id = "backup_id" old_instance_id = "old_instance_id" self.assertRaises(Exception,self.instance.failover_create_instance,flavor, image_id, service_type, volume_size, security_groups, backup_id, old_instance_id) when(utils).poll_until(any(), sleep_time=any(), time_out=any()).thenReturn(None) self.assertEqual(None,self.instance.failover_create_instance(flavor, image_id, service_type, volume_size, security_groups, backup_id, old_instance_id)) pass
def test_allocate_vip_with_vip_address(self): instance_id = "instance-id" vip_address = "vip_address" instance = fake() server =fake() server.networks = {"private": [ "10.1.0.13"] } instance.server = server when(BuiltInstance).load(any(), any()).thenReturn(instance) when(instance_vip).create_member(any(),any(),any(),any(),any()).thenReturn('member_id') vip = fake() vip.id = "vip_id" vip.lb_id = "lb_id" when(models.DBVips).find_by(any(),vip=any(),deleted=any()).thenReturn(vip) when(models.DBInstanceVip).create(instance_id=any(),rip=any(),rport=any(),vip_id=any(),mid=any()).thenReturn(None) vip_1= vip_service.allocate(self.context,instance_id,vip_address=vip_address) self.assertEqual(vip_address,vip_1) verify(instance_vip,times=0).create_pool(any(),any()) verify(instance_vip,times=0).create_vip(any(),any(),any(),any()) verify(models.DBVips,times=0).create(vip=any(),vport=any(),lb_id =any()) verify(instance_vip).create_member(any(),any(),any(),any(),any()) verify(models.DBVips).find_by(any(),vip=any(),deleted=any())
def test_upgrade_ha(self): instance_type = InstanceType.STANDBY instance = fake() instance.id = 1 instance.context = self.context instance.name = 'name' instance.flavor_id = 'flavor_id' instance.service_type = 'service_type' instance.volume_size = 'volume_size' instance.group_id = 'group_id' when(KSC_Instance)._create_instance(any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any()).thenReturn(None) group_item = fake() group_item.id = 1 group_item.group_id = 1 group_item.type = DBInstanceType.SINGLE when(InstanceGroupItem).get_by_instance_id(any(), any()).thenReturn(group_item) service = {'image_id':''} when(ServiceImage).find_by(service_name=any()).thenReturn(service) when(Backup).get_latest_backup(any(), group_id =any()).thenReturn(None) when(KSC_Instance).is_service_active(any(), instance_id=any()).thenReturn(None) when(KSC_Instance).is_lastbackup_ready(any(), instance_id=any()).thenReturn(None) self.assertEqual(None,KSC_Instance.upgrade_ha(instance))
def test_create_ha_instance(self): backup_item = fake() backup_item.id = 1 when(Backup).get_latest_backup(any(), group_id =any()).thenReturn(backup_item) when(FreshInstanceTasks).load(any(),any()).thenReturn(self.instance) when(FreshInstanceTasks).create_instance(any(), any(), any(), any(), any(), any(), any(), any(), any(), ignore_hosts=any(), master_id=any(), extend=any()).thenReturn(None) group_item = fake() group_item.group_id = 1 when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item) when(models.Instance).get_pyhhostname(any(),any()).thenReturn("master_phyhost") slave_id = "slave_id" slave_name = "slave_name" flavor = "flavor" image_id = "image_id" databases = "databases" users = "users" service_type = "service_type" volume_size = "volume_size" security_groups = "security_groups" extend = "extend" backup_id = "backup_id" self.instance.create_ha_instance(slave_id, slave_name, flavor, image_id, databases, users, service_type, volume_size, security_groups, extend, backup_id)
def delete_default_confg(): self.test_create_default_config() self.fake_context = fake() self.fake_context.limit = 1000 self.fake_context.marker = None self.fake_context.is_admin = False self.fake_context['tenant'] = self.fake_tenantid self.fake_environ = {wsgi.CONTEXT_KEY : self.fake_context} self.fake_request = fake() self.fake_request.url = "http://fore.com/***" self.fake_request.environ = self.fake_environ self.cnf_controller.delete(self.fake_request, self.fake_tenantid, self.conf_id)
def test_nameIsEmpty(self): req = fake() req.__setitem__("environ", {"trove.context":self.context}) req.__setitem__("GET", {}) group_id = "123" res = self.controller.slowquerys(req, self.context.tenant, group_id) self.assertTrue(('slowquery_path' in res.data("")), 'bad return value')
def test_configuration(self): req = fake() tenant_id = 'TENANT-2014-08-11 14:11:11.427932' self.context.tenant = tenant_id req.environ = {wsgi.CONTEXT_KEY:self.context} instance_id = '202b1984-58af-4879-abff-2a8ca3d956b8' self.controller.configuration(req, tenant_id, instance_id)
def test_check_backup(self): backup = fake() backup.is_running = False backup.location="/exist/path/backup" when(Backup).get_by_id(any(),any()).thenReturn(backup) when(Backup).check_object_exist(any(),any()).thenReturn(True) self.assertEqual(None,models.Instance._check_backup(self.context,"backup_id"))
def test_check_backup_BackupNotCompleteError(self): backup = fake() backup.location="/exist/path/backup" backup.is_running = True when(Backup).get_by_id(any(),any()).thenReturn(backup) self.assertRaises(exception.BackupNotCompleteError,models.Instance._check_backup,self.context,"backup_id") verify(Backup).get_by_id(any(),any()) verify(Backup,times=0).check_object_exist(any(),any())
def test_getSlowqueryPath(self): req = fake() req.__setitem__("environ", {"trove.context":self.context}) req.__setitem__("GET", {"name":"1111"}) group_id = "123" res = self.controller.slowquerys(req, self.context.tenant, group_id) self.assertTrue(('slowquery_path' in res.data("")), 'bad return value') print res.data('data_for_json')
def test_is_lastbackup_ready(self): instance_id = "instance_id" group_item = fake() group_item.group_id = 1 when(InstanceGroupItem).get_by_instance_id(any(), any()).thenReturn(group_item) when(Backup).get_latest_backup(any(), group_id =any()).thenReturn(None) self.assertRaises(exception.TroveError,KSC_Instance.is_lastbackup_ready,self.context,instance_id) backup_item = fake() backup_item.id = 1 backup_item.state = BackupState.FAILED when(Backup).get_latest_backup(any(), group_id =any()).thenReturn(backup_item) self.assertRaises(exception.TroveError,KSC_Instance.is_lastbackup_ready,self.context,instance_id) backup_item.state = BackupState.COMPLETED self.assertEquals(True,KSC_Instance.is_lastbackup_ready(self.context,instance_id))
def test_release_vip(self): vip = fake() vip.id = "vip_id" vip.lb_id = "lb_id" when(models.DBVips).find_by(any(),vip=any(),deleted=any()).thenReturn(vip) instance = fake() instance.instance_id = "" when(models.DBInstanceVip).find_all(vip_id = any(),deleted=any()).thenReturn([instance]) lb_vip = {"vip":{"pool_id":"pool_id"}} when(instance_vip.InstanceVip).deallocate(any(), any()).thenReturn(lb_vip) when(instance_vip).find_vip(any(),any()).thenReturn(None) when(instance_vip).delete_vip(any(),any()).thenReturn(None) when(instance_vip).delete_pool(any(),any()).thenReturn(None)
def test_groupIdIsEmpty(self): req = fake() req.__setitem__("environ", {"trove.context":self.context}) req.__setitem__("GET", {"name":"1111"}) group_id = "" try: self.controller.slowquerys(req, self.context.tenant, group_id) except exception.BadRequest, e: self.assertEquals("The group no found", e.message)
def setUp(self): super(Test_FreshInstanceTask, self).setUp() db_info = fake() db_info.hostname = "hostname" db_info.name = "name" db_info.id = "id" db_info.task_status = InstanceTasks.NONE server = None service_status = None self.instance = FreshInstanceTasks(self.context, db_info, server, service_status)
def test_check_backup_BackupFileNotFound(self): backup = fake() backup.is_running = False backup.location="/exist/path/backup" when(Backup).get_by_id(any(),any()).thenReturn(backup) when(Backup).check_object_exist(any(),any()).thenReturn(False) self.assertRaises(exception.BackupFileNotFound,models.Instance._check_backup,self.context,"backup_id") verify(Backup,times=1).get_by_id(any(),any()) verify(Backup,times=1).check_object_exist(any(),any())
def _get_instance_task(self): dbinst = DBInstance(InstanceTasks.NONE,name = 'name', created ='created', compute_instance_id = 'compute_instance_id', task_id = 'task_id', task_description = 'task_description', task_start_time = 'task_start_time', volume_id = 'volume_id', deleted = 'deleted', tenant_id = 'tenant_id', service_type = 'service_type') server = fake() service_status = fake() service_status.status = ServiceStatuses.RUNNING # inst = BaseInstance(self.context,dbinst,server,service_status) inst = BuiltInstanceTasks(self.context,dbinst,server,service_status) when(inst_models).load_instance(any(), any(), any(), needs_server=any()).thenReturn(inst) instance_tasks = BuiltInstanceTasks.load(self.context,"instance_id") return instance_tasks
def test_delete(self): dbinst = models.DBInstance(InstanceTasks.NONE,name = 'name', created ='created', compute_instance_id = 'compute_instance_id', task_id = 'task_id', task_description = 'task_description', task_start_time = 'task_start_time', volume_id = 'volume_id', deleted = 'deleted', tenant_id = 'tenant_id', service_type = 'service_type') server = fake() service_status = fake() service_status.status = ServiceStatuses.RUNNING inst = models.BaseInstance(self.context,dbinst,server,service_status) when(models).load_instance(any(), any(), any(), needs_server=any()).thenReturn(inst) group_item = fake() group_item.type = DBInstanceType.MASTER group_item.group_id = "group_id" when(InstanceGroupItem).get_by_instance_id(any(),any()).thenReturn(group_item) when(Backup).running(any()).thenReturn(False) when(models.BaseInstance).update_db(task_status=any()).thenReturn(None) when(task_api.API).delete_instance(any()).thenReturn(None) standby = fake() standby.instance_id = "instance_id" when(InstanceGroupItem).get_by_gid_type(any(), any(),any()).thenReturn(standby) standby_dbinfo = fake() def save(): pass standby_dbinfo.save = save when(models.DBInstance).find_by(id=any(), deleted=any()).thenReturn(standby_dbinfo) instance = models.load_any_instance(self.context, "id") instance.delete() verify(InstanceGroupItem).get_by_gid_type(any(), any(),any()) verify(models.DBInstance,times=1).find_by(id=any(), deleted=any())
def test_get_create_param_RR(self): req = fake() req.environ = {wsgi.CONTEXT_KEY:""} master = fake() master.service_type = "mysql" master.name = "test-master" master.flavor_id = "flavor_1" master.volume_size = "123" when(models.ServiceImage).find_by(service_name=any()).thenReturn({'image_id':"123"}) when(models.BuiltInstance).load(any(), id=any()).thenReturn(master) _expect_val = ('', 'test.test-master_readrepli', 'flavor_1', '123', [], None, 'mysql', '123', None, InstanceType.RR, None, 'INSTANCE_ID_XXXXXXXXX') ret = self.controller._get_create_param(req, self._body("RR", instance_id="INSTANCE_ID_XXXXXXXXX"), InstanceType.RR) self.assertEqual(_expect_val,ret) print 'test_get_create_param_RR'
def test_update(self): req = fake() tenant_id = 'TENANT-2014-08-11 14:14:02.358192' self.context.tenant = tenant_id req.environ = {wsgi.CONTEXT_KEY:self.context} #body = self._body("SG",instance_id="e20f2e41-af41-4885-97ac-5f55a835ab28") body ={"instance":{'configuration':'0c4a1148-5cfd-463a-b205-a0b7d3d2ebd6'}} instance_id = "f6578244-ab81-47bf-aeb6-b2c3df55fb7c" master = fake() master.service_type = "mysql" master.name = "test-master" master.flavor_id = "flavor_1" master.volume_size = "123" master.context = self.context #print self.context #master.context.is_admin = False master.configuration_id = "" master.id = instance_id when(models.Instance).load(any(), id=any()).thenReturn(master) self.controller.update(req,instance_id, body, tenant_id)
def test_deallocate(self): instance_id = "instance_id" vip = fake() vip.id = "vip_id" vip.lb_id = "lb_id" vip.mid = "mid" def delete(): pass vip.delete = delete when(models.DBInstanceVip).find_by(any(),instance_id=any(),deleted=any()).thenReturn(vip) when(instance_vip).delete_member(any(),any()).thenReturn(None) self.assertEqual(None, vip_service.deallocate(self.context, instance_id))
def test_restore_failed(self): _bk = self._create_restore_strategy() process = fake() process.pid = "pid" def _terminate(): pass process.terminate = _terminate process.stderr = self._read_fake_output("prepare_error") when(_bk)._pre_restore().thenReturn(None) when(_bk)._post_restore().thenReturn(None) when(subprocess).Popen(_bk.prepare_cmd, shell=True, stdin=subprocess.PIPE, stderr=subprocess.PIPE).thenReturn(process) self.assertRaises(Exception,_bk.restore)
def test_get_create_param_SG(self): req = fake() req.environ = {wsgi.CONTEXT_KEY:""} when(models.ServiceImage).find_by(service_name=any()).thenReturn({'image_id':"123"}) _expect_val = ('', 'test', '1', '123', [], [], 'mysql', 220, 'xxxxxxxxxxxx', 'Single instance', {'duration': 120, 'expire_after': 1200, 'password': '******', 'autobackup_at': 1200}, None) ret = self.controller._get_create_param(req, self._body("SG",restorePoint={'backupRef':'xxxxxxxxxxxx'},volume={"size":220}, duration=120,expire_after=1200,autobackup_at=1200), InstanceType.SG) ret = _expect_val self.assertEqual(_expect_val,ret)
def test_group_info(self): CONF.remote_implementation = "fake" _ret = fake() _ret.status = models.ServiceStatuses.RUNNING when(models.InstanceServiceStatus).find_by(instance_id=any()).thenReturn(_ret) api = rpcapi.API(self.context) id = self._create_group() self._create(id,MASTER) self._create(id,STANDBY) self._create(id,READ_REPLI) self._create(id,READ_REPLI) self._create(id,READ_REPLI) api.group_update(id)
def test_create_server_volume_individually(self): flavor_id = "flavor_id" image_id = "image_id" security_groups = "security_groups" service_type = "service_type" volume_size = "volume_size" ignore_hosts=None server = fake() server.id = 1 when(FreshInstanceTasks)._create_server(any(), any(), any(), any(), any(), any()).thenReturn(server) when(FreshInstanceTasks).update_db(compute_instance_id=any()).thenReturn(None) self.assertNotEqual(None,self.instance._create_server_volume_individually(flavor_id, image_id, security_groups, service_type, volume_size,ignore_hosts))
def test_create_rr(self): name = "NAME" flavor_id = "flavor_id" image_id = "image_id" databases = "databases" users = "users" service_type = "mysql" volume_size = "10" backup_id = "backup_id" master_id = "master_id" extend = "" when(KSC_Instance)._create_instance(any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any(), any()).thenReturn(None) instance_type = InstanceType.RR group_item = fake() group_item.id = 1 group_item.type = DBInstanceType.MASTER when(InstanceGroupItem).get_by_instance_id(any(), any()).thenReturn(group_item) when(KSC_Instance).is_service_active(any(), instance_id=any()).thenReturn(None) when(KSC_Instance).is_lastbackup_ready(any(), instance_id=any()).thenReturn(None) self.assertEqual(None,KSC_Instance.create(self.context, name, flavor_id, image_id, databases, users, service_type, volume_size, backup_id,instance_type,extend,master_id)) verify(InstanceGroupItem).get_by_instance_id(any(), any()) group_item.type = DBInstanceType.STANDBY self.assertRaises(Exception,KSC_Instance.create,self.context, name, flavor_id, image_id, databases, users, service_type, volume_size, backup_id,instance_type,extend,master_id) when(KSC_Instance).is_service_active(any(), instance_id=any()).thenRaise(Exception("is_service_active")) group_item.type = DBInstanceType.MASTER self.assertRaises(Exception,KSC_Instance.create,self.context, name, flavor_id, image_id, databases, users, service_type, volume_size, backup_id,instance_type,extend,master_id)