def setUp(self): """Set an elastic search config var.""" super(OtterHistoryTestCase, self).setUp() self.root = Otter(None, 'ord', es_host='http://dummy').app.resource() set_config_data({ 'limits': {'pagination': 20}, 'url_root': 'http://localhost'}) self.addCleanup(set_config_data, {}) self.log = patch(self, 'otter.rest.history.log', new=mock_log()) self.make_auditlog_query = patch( self, 'otter.rest.history.make_auditlog_query', return_value={'tenant_id': 101010}) self.treq = patch(self, 'otter.rest.history.treq', new=mock_treq( code=200, method='get', json_content={ 'hits': { 'hits': [{ '_source': { 'message': 'audit log event', 'event_type': 'event-abc', '@timestamp': 1234567890, 'policy_id': 'policy-xyz', 'scaling_group_id': 'scaling-group-uvw', 'server_id': 'server-rst', 'throwaway_key': 'ignore me!!!!' } }] } }))
def setUp(self): """ Replace the store every time with a clean one. """ store = MockScalingGroupCollection() self.root = Otter(store).app.resource() set_config_data({'url_root': 'http://127.0.0.1', 'limits': {'pagination': 5}}) self.addCleanup(set_config_data, {}) self.config = config()[1] self.config['minEntities'] = 0 self.active_pending_etc = ({}, {}, 'date', {}, False) # patch both the config and the groups self.mock_controller = patch(self, 'otter.rest.configs.controller', spec=['obey_config_change']) patch(self, 'otter.rest.groups.controller', new=self.mock_controller) # Patch supervisor supervisor = mock.Mock(spec=['validate_launch_config']) supervisor.validate_launch_config.return_value = defer.succeed(None) set_supervisor(supervisor) def _mock_obey_config_change(log, trans, config, group, state): return defer.succeed(GroupState( state.tenant_id, state.group_id, state.group_name, *self.active_pending_etc)) self.mock_controller.obey_config_change.side_effect = _mock_obey_config_change
def setUp(self): """ mock all the dependent functions and data """ self.log = mock.Mock() self.data = { "1": {"created": "2014-01-01T00:00:05Z.1234", "id": "1", "lb": "lb"}, "2": {"created": "2014-01-04T00:02:02Z", "id": "2", "lb": "lb"}, "3": {"created": "2014-01-04T00:00:10Z", "id": "3", "lb": "lb"}, "4": {"created": "2014-01-01T01:00:00Z.3513", "id": "4", "lb": "lb"}, "5": {"created": "2014-01-05T00:00:00Z", "id": "5", "lb": "lb"}, } # ascending order by time would be: 1, 4, 3, 2, 5 self.fake_state = GroupState("t", "g", "n", self.data, {}, False, False, False, ScalingGroupStatus.ACTIVE) self.evict_servers = {"1": self.data["1"], "4": self.data["4"], "3": self.data["3"]} self.find_servers_to_evict = patch( self, "otter.supervisor.find_servers_to_evict", return_value=self.evict_servers.values() ) self.jobs = [mock.Mock(), mock.Mock(), mock.Mock()] self.del_job = patch(self, "otter.supervisor._DeleteJob", side_effect=self.jobs) self.supervisor = iMock(ISupervisor) self.supervisor.deferred_pool = DeferredPool() patch(self, "otter.supervisor.get_supervisor", return_value=self.supervisor)
def setUp(self): """ Set the Cassandra store, and also patch the controller """ keyspace.resume() set_store(store) set_config_data({'url_root': 'http://127.0.0.1'}) self.addCleanup(set_config_data, {}) self.config = config()[0] self.config['minEntities'] = 0 self.active_pending_etc = ({}, {}, 'date', {}, False) # patch both the config and the groups self.mock_controller = patch(self, 'otter.rest.configs.controller', spec=['obey_config_change']) patch(self, 'otter.rest.groups.controller', new=self.mock_controller) def _mock_obey_config_change(log, trans, config, group, state): return defer.succeed(GroupState( state.tenant_id, state.group_id, *self.active_pending_etc)) self.mock_controller.obey_config_change.side_effect = _mock_obey_config_change self.lock = self.mock_lock() patch(self, 'otter.models.cass.BasicLock', return_value=self.lock)
def setUp(self): """ Setup fake supervisor and fake job """ self.supervisor = FakeSupervisor() set_supervisor(self.supervisor) self.addCleanup(set_supervisor, None) self.log = mock_log() self.jobs = [] class FakeJob(object): def __init__(jself, *args): jself.args = args jself.job_id = len(self.jobs) + 10 self.jobs.append(jself) def start(jself, launch): jself.launch = launch jself.d = Deferred() return jself.d patch(self, "otter.supervisor._Job", new=FakeJob) self.state = GroupState("t", "g", "n", {}, {}, 0, 1, 2, ScalingGroupStatus.ACTIVE)
def setUp(self): """ Set up treq patch. """ self.treq = patch(self, 'otter.auth.treq') patch(self, 'otter.util.http.treq', new=self.treq) self.log = mock.Mock()
def setUp(self): """ Mock modify state """ super(AllGroupsEndpointTestCase, self).setUp() self.mock_controller = patch(self, 'otter.rest.groups.controller') patch(self, 'otter.rest.application.get_url_root', return_value="")
def setUp(self): """ Mock a fake supervisor, and also a fake log and group. """ self.transaction_id = 'transaction_id' self.job_id = 'job_id' patch(self, 'otter.supervisor.generate_job_id', return_value=self.job_id) self.state = GroupState('tenant', 'group', 'name', {}, {}, None, {}, False, ScalingGroupStatus.ACTIVE) self.group = mock_group(self.state, 'tenant', 'group') self.supervisor = iMock(ISupervisor) self.supervisor.deferred_pool = DeferredPool() self.completion_deferred = Deferred() self.supervisor.execute_config.return_value = self.completion_deferred self.log = mock_log() self.job = supervisor._Job(self.log, self.transaction_id, self.group, self.supervisor) self.del_job = patch(self, 'otter.supervisor._DeleteJob') self.mock_launch = {'type': 'launch_server', 'args': {'server': {'imageRef': 'imageID', 'flavorRef': '1'}}}
def setUp(self): """ Replace the store every time with a clean one. """ store = MockScalingGroupCollection() set_store(store) set_config_data({'url_root': 'http://127.0.0.1'}) self.addCleanup(set_config_data, {}) self.config = config()[1] self.config['minEntities'] = 0 self.active_pending_etc = ({}, {}, 'date', {}, False) # patch both the config and the groups self.mock_controller = patch(self, 'otter.rest.configs.controller', spec=['obey_config_change']) patch(self, 'otter.rest.groups.controller', new=self.mock_controller) def _mock_obey_config_change(log, trans, config, group, state): return defer.succeed( GroupState(state.tenant_id, state.group_id, *self.active_pending_etc)) self.mock_controller.obey_config_change.side_effect = _mock_obey_config_change
def setUp(self): """ Mock all the dependencies of SchedulingService. This includes logging, store's fetch_and_delete, TxKazooClient stuff, check_events_in_bucket. """ super(SchedulerServiceTests, self).setUp() otter_log = patch(self, "otter.scheduler.otter_log") self.log = mock_log() otter_log.bind.return_value = self.log def pfactory(log, callable): self.fake_partitioner = FakePartitioner(log, callable) return self.fake_partitioner self.scheduler_service = SchedulerService("disp", 100, self.mock_store, pfactory, threshold=600) otter_log.bind.assert_called_once_with(system="otter.scheduler") self.scheduler_service.running = True self.assertIdentical(self.fake_partitioner, self.scheduler_service.partitioner) self.check_events_in_bucket = patch(self, "otter.scheduler.check_events_in_bucket") self.returns = [] self.setup_func(self.mock_store.get_oldest_event)
def setUp(self): """ Setup fake supervisor and fake job """ self.supervisor = FakeSupervisor() set_supervisor(self.supervisor) self.addCleanup(set_supervisor, None) self.log = mock_log() self.jobs = [] class FakeJob(object): def __init__(jself, *args): jself.args = args jself.job_id = len(self.jobs) + 10 self.jobs.append(jself) def start(jself, launch): jself.launch = launch jself.d = Deferred() return jself.d patch(self, 'otter.supervisor._Job', new=FakeJob) self.state = GroupState('t', 'g', 'n', {}, {}, *range(3))
def setUp(self): """ Set up a silverberg client """ keyspace.resume() set_store(store) # ensure it's the cassandra store set_config_data({'url_root': 'http://127.0.0.1'}) self.addCleanup(set_config_data, {}) self._config = config()[0] self._launch = launch_server_config()[0] self.mock_controller = patch(self, 'otter.rest.policies.controller') self.lock = self.mock_lock() patch(self, 'otter.models.cass.BasicLock', return_value=self.lock) def _set_group_id(manifest): self.group_id = manifest['id'] self.policies_url = ( '/v1.0/{tenant}/groups/{group}/policies/'.format( tenant=self.tenant_id, group=self.group_id)) self.mock_controller.maybe_execute_scaling_policy.return_value = defer.succeed( GroupState(self.tenant_id, self.group_id, {}, {}, 'date', {}, False)) mock_log = mock.MagicMock() d = store.create_scaling_group(mock_log, self.tenant_id, self._config, self._launch) d.addCallback(_set_group_id) return d
def setUp(self): """ Set the Cassandra store, and also patch the controller """ keyspace.resume() set_store(store) set_config_data({'url_root': 'http://127.0.0.1'}) self.addCleanup(set_config_data, {}) self.config = config()[0] self.config['minEntities'] = 0 self.active_pending_etc = ({}, {}, 'date', {}, False) # patch both the config and the groups self.mock_controller = patch(self, 'otter.rest.configs.controller', spec=['obey_config_change']) patch(self, 'otter.rest.groups.controller', new=self.mock_controller) def _mock_obey_config_change(log, trans, config, group, state): return defer.succeed( GroupState(state.tenant_id, state.group_id, *self.active_pending_etc)) self.mock_controller.obey_config_change.side_effect = _mock_obey_config_change self.lock = self.mock_lock() patch(self, 'otter.models.cass.BasicLock', return_value=self.lock)
def setUp(self): """ Shortcut by mocking all the helper functions that do IO. """ self.authenticate_user = patch(self, 'otter.auth.authenticate_user') self.user_for_tenant = patch(self, 'otter.auth.user_for_tenant') self.impersonate_user = patch(self, 'otter.auth.impersonate_user') self.endpoints_for_token = patch(self, 'otter.auth.endpoints_for_token') self.authenticate_user.side_effect = lambda *a, **kw: succeed( {'access': {'token': {'id': 'auth-token'}}}) self.user_for_tenant.side_effect = lambda *a, **kw: succeed('test_user') self.impersonate_user.side_effect = lambda *a, **kw: succeed( {'access': {'token': {'id': 'impersonation_token'}}}) self.endpoints_for_token.side_effect = lambda *a, **kw: succeed( {'endpoints': [{'name': 'anEndpoint', 'type': 'anType'}]}) self.url = 'http://identity/v2.0' self.admin_url = 'http://identity_admin/v2.0' self.user = '******' self.password = '******' self.ia = ImpersonatingAuthenticator(self.user, self.password, self.url, self.admin_url) self.log = mock.Mock()
def setUp(self): """ Mock the interface :return: None """ self.mock_store = iMock(IScalingGroupCollection) self.mock_group = iMock(IScalingGroup) self.mock_store.get_scaling_group.return_value = self.mock_group self.mock_generate_transaction_id = patch( self, 'otter.rest.decorators.generate_transaction_id', return_value='transaction-id') # mock out modify state self.mock_state = mock.MagicMock(spec=[]) # so nothing can call it def _mock_modify_state(modifier, *args, **kwargs): modifier(self.mock_group, self.mock_state, *args, **kwargs) return defer.succeed(None) self.mock_group.modify_state.side_effect = _mock_modify_state self.root = Otter(self.mock_store).app.resource() self.get_url_root = patch(self, 'otter.util.http.get_url_root', return_value="") # set pagination limits as it'll be used by all rest interfaces set_config_data({'limits': {'pagination': 100}})
def setUp(self): """ Set the Cassandra store, and also patch the controller """ keyspace.resume() self.root = Otter(store, 'ord').app.resource() set_config_data(limits) self.addCleanup(set_config_data, {}) self.config = config()[0] self.config['minEntities'] = 0 self.active_pending_etc = (self.config['name'], {}, {}, 'date', {}, False) # patch both the config and the groups self.mock_controller = patch(self, 'otter.rest.configs.controller', spec=['obey_config_change']) patch(self, 'otter.rest.groups.controller', new=self.mock_controller) # Patch supervisor supervisor = mock.Mock(spec=['validate_launch_config']) supervisor.validate_launch_config.return_value = defer.succeed(None) set_supervisor(supervisor) def _mock_obey_config_change(log, trans, config, group, state, launch_config): return defer.succeed(GroupState( state.tenant_id, state.group_id, *self.active_pending_etc)) self.mock_controller.obey_config_change.side_effect = _mock_obey_config_change store.kz_client = mock.Mock(Lock=self.mock_lock())
def setUp(self): """ mock all the dependencies of SchedulingService that includes logging, store's fetch_and_delete, TxKazooClient stuff, TimerService, check_events_in_bucket and twisted.internet.task.Clock is used to simulate time """ super(SchedulerServiceTests, self).setUp() otter_log = patch(self, 'otter.scheduler.otter_log') self.log = mock_log() otter_log.bind.return_value = self.log self.kz_client = mock.Mock(spec=['SetPartitioner']) self.kz_partition = mock.MagicMock(allocating=False, release=False, failed=False, acquired=False) self.kz_client.SetPartitioner.return_value = self.kz_partition self.zk_partition_path = '/part_path' self.time_boundary = 15 self.buckets = range(1, 10) self.clock = Clock() self.scheduler_service = SchedulerService( 100, 1, self.mock_store, self.kz_client, self.zk_partition_path, self.time_boundary, self.buckets, self.clock, threshold=600) otter_log.bind.assert_called_once_with(system='otter.scheduler') self.timer_service = patch(self, 'otter.scheduler.TimerService') self.check_events_in_bucket = patch(self, 'otter.scheduler.check_events_in_bucket') self.returns = [] self.setup_func(self.mock_store.get_oldest_event)
def setUp(self): """ Mock all the dependencies of SchedulingService. This includes logging, store's fetch_and_delete, TxKazooClient stuff, check_events_in_bucket. """ super(SchedulerServiceTests, self).setUp() otter_log = patch(self, 'otter.scheduler.otter_log') self.log = mock_log() otter_log.bind.return_value = self.log def pfactory(log, callable): self.fake_partitioner = FakePartitioner(log, callable) return self.fake_partitioner self.scheduler_service = SchedulerService("disp", 100, self.mock_store, pfactory, threshold=600) otter_log.bind.assert_called_once_with(system='otter.scheduler') self.scheduler_service.running = True self.assertIdentical(self.fake_partitioner, self.scheduler_service.partitioner) self.check_events_in_bucket = patch( self, 'otter.scheduler.check_events_in_bucket') self.returns = [] self.setup_func(self.mock_store.get_oldest_event)
def setUp(self): """ mock dependent objects and functions """ self.log = mock.Mock() self.pending = { '1': {'created': '0001-01-01T00:00:05Z.0001'}, '2': {'created': '0001-01-04T00:02:02Z'}, '3': {'created': '0001-01-04T00:00:10Z'}, '4': {'created': '0001-01-01T01:00:00Z.3513'}, '5': {'created': '0001-01-05T00:00:00Z'} } # descending order by time would be: 5, 2, 3, 4, 1 self.active = { 'a1': {'created': '0001-01-01T00:00:05Z.0001', 'id': '1', 'lb': 'lb'}, 'a2': {'created': '0001-01-04T00:02:02Z', 'id': '2', 'lb': 'lb'}, 'a3': {'created': '0001-01-04T00:00:10Z', 'id': '3', 'lb': 'lb'}, 'a4': {'created': '0001-01-01T01:00:00Z.3513', 'id': '4', 'lb': 'lb'}, 'a5': {'created': '0001-01-05T00:00:00Z', 'id': '5', 'lb': 'lb'} } # ascending order by time would be: a1, a4, a3, a2, a5 self.fake_state = GroupState('t', 'g', '', self.active, self.pending, False, False, False) self.find_pending_jobs_to_cancel = patch( self, 'otter.supervisor.find_pending_jobs_to_cancel') self.del_active_servers = patch( self, 'otter.supervisor.delete_active_servers')
def setUp(self): """ Shortcut by mocking all the helper functions that do IO. """ self.authenticate_user = patch(self, 'otter.auth.authenticate_user') self.user_for_tenant = patch(self, 'otter.auth.user_for_tenant') self.impersonate_user = patch(self, 'otter.auth.impersonate_user') self.endpoints_for_token = patch(self, 'otter.auth.endpoints_for_token') self.authenticate_user.return_value = succeed( {'access': { 'token': { 'id': 'auth-token' } }}) self.user_for_tenant.return_value = succeed('test_user') self.impersonate_user.return_value = succeed( {'access': { 'token': { 'id': 'impersonation_token' } }}) self.endpoints_for_token.return_value = succeed( {'endpoints': [{ 'name': 'anEndpoint', 'type': 'anType' }]}) self.url = 'http://identity/v2.0' self.admin_url = 'http://identity_admin/v2.0' self.user = '******' self.password = '******' self.ia = ImpersonatingAuthenticator(self.user, self.password, self.url, self.admin_url)
def setUp(self): """ mock all the dependent functions and data """ self.log = mock.Mock() self.data = { '1': {'created': '0001-01-01T00:00:05Z.0001', 'id': '1', 'lb': 'lb'}, '2': {'created': '0001-01-04T00:02:02Z', 'id': '2', 'lb': 'lb'}, '3': {'created': '0001-01-04T00:00:10Z', 'id': '3', 'lb': 'lb'}, '4': {'created': '0001-01-01T01:00:00Z.3513', 'id': '4', 'lb': 'lb'}, '5': {'created': '0001-01-05T00:00:00Z', 'id': '5', 'lb': 'lb'} } # ascending order by time would be: 1, 4, 3, 2, 5 self.fake_state = GroupState('t', 'g', 'n', self.data, {}, False, False, False) self.evict_servers = {'1': self.data['1'], '4': self.data['4'], '3': self.data['3']} self.find_servers_to_evict = patch( self, 'otter.supervisor.find_servers_to_evict', return_value=self.evict_servers.values()) self.jobs = [mock.Mock(), mock.Mock(), mock.Mock()] self.del_job = patch( self, 'otter.supervisor._DeleteJob', side_effect=self.jobs) self.supervisor = iMock(ISupervisor) self.supervisor.deferred_pool = DeferredPool() patch(self, 'otter.supervisor.get_supervisor', return_value=self.supervisor)
def setUp(self): """mock `extract_clb_drained_at`""" self.feeds = {'11feed': 1.0, '22feed': 2.0} self.mock_eda = patch( self, 'otter.convergence.gathering.extract_clb_drained_at', side_effect=lambda f: self.feeds[f]) patch(self, "otter.convergence.gathering.get_clb_node_feed", side_effect=intent_func("gcnf"))
def setUp(self): """ set up test dependencies for load balancers. """ self.treq = patch(self, 'otter.worker.launch_server_v1.treq') patch(self, 'otter.util.http.treq', new=self.treq) self.undo = iMock(IUndoStack)
def setUp(self): """ Mock treq """ self.log = mock_log() self.treq = patch(self, "otter.worker.validate_config.treq", new=mock_treq(code=200, method="get")) patch(self, "otter.util.http.treq", new=self.treq) self.headers = {"content-type": ["application/json"], "accept": ["application/json"]}
def setUp(self): """ Mock remove_server_from_group """ super(GroupServersTests, self).setUp() self.mock_rsfg = patch(self, 'otter.rest.groups.remove_server_from_group', return_value=None) self.mock_eba = patch(self, 'otter.rest.groups.extract_bool_arg', return_value=True)
def setUp(self): """ Set up mock Bobby client """ set_bobby(BobbyClient("http://127.0.0.1:9876/")) super(AllGroupsBobbyEndpointTestCase, self).setUp() self.mock_controller = patch(self, 'otter.rest.groups.controller') patch(self, 'otter.rest.application.get_url_root', return_value="")
def setUp(self): """ Mock get_autoscale_links and get_collection_links """ self.gal = patch(self, 'otter.util.http.get_autoscale_links', return_value='url') self.gcl = patch(self, 'otter.util.http.get_collection_links', return_value='col links')
def setUp(self): """ Set up some mocks. """ set_config_data(fake_config) self.addCleanup(set_config_data, {}) self.log = mock_log() self.treq = patch(self, 'otter.worker.launch_server_v1.treq') patch(self, 'otter.util.http.treq', new=self.treq)
def setUp(self): """ Configure mocks for Site and the strports service constructor. """ self.service = patch(self, 'otter.tap.api.service') self.Site = patch(self, 'otter.tap.api.Site') self.clientFromString = patch(self, 'otter.tap.api.clientFromString') self.RoundRobinCassandraCluster = patch(self, 'otter.tap.api.RoundRobinCassandraCluster') self.LoggingCQLClient = patch(self, 'otter.tap.api.LoggingCQLClient') self.log = patch(self, 'otter.tap.api.log') Otter_patcher = mock.patch('otter.tap.api.Otter') self.Otter = Otter_patcher.start() self.addCleanup(Otter_patcher.stop) self.CassScalingGroupCollection = patch(self, 'otter.tap.api.CassScalingGroupCollection') self.store = self.CassScalingGroupCollection.return_value self.health_checker = None def make_health_checker(*args, **kwargs): self.health_checker = HealthChecker(*args, **kwargs) return self.health_checker patch(self, 'otter.tap.api.HealthChecker', side_effect=make_health_checker)
def setUp(self): """ Mock `execute_event` and `add_cron_events` """ super(ProcessEventsTests, self).setUp() self.execute_event = patch(self, 'otter.scheduler.execute_event', return_value=defer.succeed(None)) self.add_cron_events = patch( self, 'otter.scheduler.add_cron_events', side_effect=lambda store, log, events, deleted_policy_ids: defer.succeed(events)) self.log = mock_log()
def setUp(self): """ Mock cass connection and authenticator """ self.client = mock.Mock(spec=["disconnect"]) self.client.disconnect.return_value = succeed("disconnected") self.mock_ccs = patch(self, "otter.metrics.connect_cass_servers", return_value=self.client) self.mock_cm = patch(self, "otter.metrics.collect_metrics", return_value=succeed(None)) self.config = {"cassandra": "c", "identity": identity_config, "metrics": {"interval": 20}} self.log = mock_log() self.clock = Clock()
def setUp(self): """ Mock treq """ self.log = mock_log() self.treq = patch(self, 'otter.worker.validate_config.treq', new=mock_treq(code=200, method='get')) patch(self, 'otter.util.http.treq', new=self.treq) self.headers = {'content-type': ['application/json'], 'accept': ['application/json'], 'User-Agent': ['OtterScale/0.0']}
def setUp(self): """ mock worker functions and other dependant objects """ super(LaunchConfigTests, self).setUp() self.launch_server = patch( self, "otter.worker.launch_server_v1.launch_server", return_value=succeed((self.fake_server_details, {})) ) self.generate_job_id = patch(self, "otter.supervisor.generate_job_id") self.generate_job_id.return_value = "job-id" self.launch_config = {"type": "launch_server", "args": {"server": {}}}
def setUp(self): """ mock all the dependencies of SchedulingService that includes cass store, store's fetch and delete events methods, scaling group on which controller will execute scaling policy. Hence, controller.maybe_execute_scaling_policy. twisted.internet.task.Clock is used to simulate time """ self.mock_store = iMock(IScalingGroupCollection, IScalingScheduleCollection) self.mock_group = iMock(IScalingGroup) self.mock_store.get_scaling_group.return_value = self.mock_group self.returns = [None] def _responses(*args): result = self.returns.pop(0) if isinstance(result, Exception): return defer.fail(result) return defer.succeed(result) self.mock_store.fetch_batch_of_events.side_effect = _responses self.mock_store.delete_events.return_value = defer.succeed(None) self.mock_generate_transaction_id = patch( self, 'otter.scheduler.generate_transaction_id', return_value='transaction-id') set_store(self.mock_store) self.addCleanup(set_store, None) # mock out modify state self.mock_state = mock.MagicMock(spec=[]) # so nothing can call it def _mock_modify_state(modifier, *args, **kwargs): modifier(self.mock_group, self.mock_state, *args, **kwargs) return defer.succeed(None) self.mock_group.modify_state.side_effect = _mock_modify_state self.mock_log = mock.MagicMock() self.mock_controller = patch(self, 'otter.scheduler.controller') def _mock_with_lock(lock, func, *args, **kwargs): return defer.maybeDeferred(func, *args, **kwargs) self.mock_lock = patch(self, 'otter.scheduler.BasicLock') self.mock_with_lock = patch(self, 'otter.scheduler.with_lock') self.mock_with_lock.side_effect = _mock_with_lock self.slv_client = mock.MagicMock() self.clock = Clock() self.scheduler_service = SchedulerService(100, 1, self.slv_client, self.clock)
def setUp(self): """ Mock `execute_event` and `add_cron_events`. """ super(ProcessEventsTests, self).setUp() self.execute_event = patch(self, "otter.scheduler.execute_event", return_value=defer.succeed(None)) def fake_add_cron_events(store, log, events, deleted_policy_ids): return defer.succeed(events) self.add_cron_events = patch(self, "otter.scheduler.add_cron_events", side_effect=fake_add_cron_events) self.log = mock_log()
def setUp(self): """ mock worker functions and other dependant objects """ super(LaunchConfigTests, self).setUp() self.launch_server = patch( self, 'otter.supervisor.launch_server_v1.launch_server', return_value=succeed((self.fake_server_details, {}))) self.generate_job_id = patch(self, 'otter.supervisor.generate_job_id') self.generate_job_id.return_value = 'job-id' self.launch_config = {'type': 'launch_server', 'args': {'server': {}}}
def setUp(self): """ Mock execution of scaling policy. """ super(ExecuteEventTests, self).setUp() self.mock_group = iMock(IScalingGroup) self.mock_store.get_scaling_group.return_value = self.mock_group # mock out modify_and_trigger self.mock_mt = patch(self, "otter.scheduler.modify_and_trigger") self.new_state = None def _set_new_state(new_state): self.new_state = new_state def _mock_modify_trigger(disp, group, logargs, modifier, modify_state_reason=None, *args, **kwargs): self.assertEqual(disp, "disp") d = modifier(group, "state", *args, **kwargs) return d.addCallback(_set_new_state) self.mock_mt.side_effect = _mock_modify_trigger self.maybe_exec_policy = patch( self, 'otter.scheduler.maybe_execute_scaling_policy', return_value=defer.succeed('newstate')) self.log = mock_log() self.log_args = { 'tenant_id': '1234', 'scaling_group_id': 'scal44', 'policy_id': 'pol44', "scheduled_time": "1970-01-01T00:00:00Z" } self.event = { 'tenantId': '1234', 'groupId': 'scal44', 'policyId': 'pol44', 'trigger': datetime(1970, 1, 1), 'cron': '*', 'bucket': 1, 'version': 'v2' }
def setUp(self): """ Mock `execute_event` and `add_cron_events`. """ super(ProcessEventsTests, self).setUp() self.execute_event = patch(self, 'otter.scheduler.execute_event', return_value=defer.succeed(None)) def fake_add_cron_events(store, log, events, deleted_policy_ids): return defer.succeed(events) self.add_cron_events = patch(self, 'otter.scheduler.add_cron_events', side_effect=fake_add_cron_events) self.log = mock_log()
def setUp(self): """ Mock the interface :return: None """ self.mock_store = iMock(IScalingGroupCollection) self.mock_group = iMock(IScalingGroup) self.mock_store.get_scaling_group.return_value = self.mock_group self.mock_generate_transaction_id = patch( self, 'otter.rest.decorators.generate_transaction_id', return_value='transaction-id') set_store(self.mock_store) self.addCleanup(set_store, None) # mock out modify state self.mock_state = mock.MagicMock(spec=[]) # so nothing can call it def _mock_modify_state(modifier, *args, **kwargs): modifier(self.mock_group, self.mock_state, *args, **kwargs) return defer.succeed(None) self.mock_group.modify_state.side_effect = _mock_modify_state
def setUp(self): """ Set up common policy mocks. """ super(OnePolicyTestCase, self).setUp() self.mock_controller = patch(self, 'otter.rest.policies.controller') setup_mod_and_trigger(self)
def setUp(self): """ Configure test resources. """ self.log = mock.Mock() self.group = iMock(IScalingGroup) self.group.tenant_id = 11111 self.group.uuid = 'group-id' self.auth_token = 'auth-token' self.service_catalog = {} self.auth_function = mock.Mock( return_value=succeed((self.auth_token, self.service_catalog))) self.fake_server_details = { 'server': { 'id': 'server_id', 'links': ['links'], 'name': 'meh', 'metadata': {} } } set_config_data({'region': 'ORD'}) self.addCleanup(set_config_data, {}) self.cooperator = mock.Mock(spec=Cooperator) self.supervisor = Supervisor(self.auth_function, self.cooperator.coiterate) self.InMemoryUndoStack = patch(self, 'otter.supervisor.InMemoryUndoStack') self.undo = self.InMemoryUndoStack.return_value self.undo.rewind.return_value = succeed(None)
def setUp(self): """ Basic Setup and patch the log """ self.mockRequest = mock.MagicMock() self.mockRequest.code = 200 self.mockRequest.uri = '/' self.mockRequest.clientproto = 'HTTP/1.1' self.mockRequest.method = 'PROPFIND' values = {'referer': 'referrer(sic)', 'user-agent': 'Mosaic/1.0'} def header_side_effect(arg): return values[arg] self.mockRequest.getHeader.side_effect = header_side_effect def mockResponseCode(code): self.mockRequest.code = code self.mockRequest.setResponseCode.side_effect = mockResponseCode self.mock_log = patch(self, 'otter.rest.decorators.log') self.hashkey_patch = mock.patch( 'otter.rest.decorators.generate_transaction_id') self.mock_key = self.hashkey_patch.start() self.mock_key.return_value = '12345678' self.addCleanup(self.hashkey_patch.stop)
def setUp(self): """ Set up webhook specific mocks. """ super(OneWebhookTestCase, self).setUp() self.mock_controller = patch(self, 'otter.rest.webhooks.controller') setup_mod_and_trigger(self) self.mock_group.uuid = self.group_id
def setUp(self): """ Mock store.add_cron_events and next_cron_occurrence. """ super(AddCronEventsTests, self).setUp() self.mock_store.add_cron_events.return_value = defer.succeed(None) self.next_cron_occurrence = patch( self, 'otter.scheduler.next_cron_occurrence', return_value='next') self.log = mock_log()
def setUp(self): """ Mock common dependencies of methods in scheduler.py. """ self.mock_store = iMock(IScalingGroupCollection, IScalingScheduleCollection) self.mock_generate_transaction_id = patch( self, 'otter.scheduler.generate_transaction_id', return_value='transaction-id')
def setUp(self): """ Set up test dependencies. """ self.log = mock_log() set_config_data(fake_config) self.addCleanup(set_config_data, {}) self.treq = patch(self, 'otter.worker.launch_server_v1.treq') patch(self, 'otter.util.http.treq', new=self.treq) self.generate_server_name = patch( self, 'otter.worker.launch_server_v1.generate_server_name') self.generate_server_name.return_value = 'as000000' self.scaling_group_uuid = '1111111-11111-11111-11111111' self.scaling_group = mock.Mock(uuid=self.scaling_group_uuid) self.undo = iMock(IUndoStack)
def setUp(self): """ Mock out the data store and logger. """ self.mock_store = iMock(IAdmin) self.mock_generate_transaction_id = patch( self, 'otter.rest.decorators.generate_transaction_id', return_value='a-wild-transaction-id') self.root = OtterAdmin(self.mock_store).app.resource()
def setUp(self): """ mock worker functions and other dependant objects """ super(DeleteServerTests, self).setUp() self.delete_server = patch( self, 'otter.supervisor.launch_server_v1.delete_server', return_value=succeed(None)) self.fake_server = self.fake_server_details['server'] self.fake_server['lb_info'] = {}
def test_pause(self): """ Pausing should call the controller's ``pause_scaling_group`` function """ mock_pause = patch(self, 'otter.rest.groups.controller.pause_scaling_group', return_value=defer.succeed(None)) response_body = self.assert_status_code(204, method="POST") self.assertEqual(response_body, "") mock_pause.assert_called_once_with(mock.ANY, 'transaction-id', self.mock_group)
def setUp(self): """ Mock cass connection and authenticator """ self.client = mock.Mock(spec=['disconnect']) self.client.disconnect.return_value = succeed('disconnected') self.mock_ccs = patch(self, 'otter.metrics.connect_cass_servers', return_value=self.client) self.mock_cm = patch(self, 'otter.metrics.collect_metrics', return_value=succeed(None)) self.config = { 'cassandra': 'c', 'identity': identity_config, 'metrics': { 'interval': 20 } } self.log = mock_log() self.clock = Clock()
def setUp(self): """ Set up some mocks. """ self.log = mock_log() self.clock = Clock() configuration = {} for method in ('request', 'head', 'get', 'put', 'patch', 'post', 'delete'): configuration['{0}.__name__'.format(method)] = method configuration['{0}.return_value'.format(method)] = Deferred() self.treq = mock.MagicMock(spec=treq, **configuration) self.response = mock.MagicMock(code=204, headers={'1': '2'}) patch(self, 'otter.util.logging_treq.treq', self.treq) patch(self, 'otter.util.logging_treq.uuid4', mock.MagicMock(spec=[], return_value='uuid')) self.url = 'myurl'
def setUp(self): """ Configure mocks for Site and the strports service constructor. """ self.service = patch(self, 'otter.tap.api.service') self.Site = patch(self, 'otter.tap.api.Site') self.clientFromString = patch(self, 'otter.tap.api.clientFromString') self.RoundRobinCassandraCluster = patch(self, 'otter.tap.api.RoundRobinCassandraCluster') self.LoggingCQLClient = patch(self, 'otter.tap.api.LoggingCQLClient') self.log = patch(self, 'otter.tap.api.log') self.set_store = patch(self, 'otter.tap.api.set_store') self.CassScalingGroupCollection = patch(self, 'otter.tap.api.CassScalingGroupCollection') SchedulerService_patcher = mock.patch('otter.tap.api.SchedulerService') self.SchedulerService = SchedulerService_patcher.start() self.addCleanup(SchedulerService_patcher.stop)
def setUp(self): """ Mock store.fetch_and_delete and `process_events` """ super(CheckEventsInBucketTests, self).setUp() self.returns = [[]] def _responses(*args): result = self.returns.pop(0) if isinstance(result, Exception): return defer.fail(result) return defer.succeed(result) self.mock_store.fetch_and_delete.side_effect = _responses self.process_events = patch( self, 'otter.scheduler.process_events', side_effect=lambda e, d, s, l: defer.succeed(len(e))) self.log = mock.Mock()