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): """ 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, modify_state_reason=None, *args, **kwargs): return defer.maybeDeferred(modifier, self.mock_group, self.mock_state, *args, **kwargs) self.mock_group.modify_state.side_effect = _mock_modify_state self.otter = Otter(self.mock_store, "ord") self.root = self.otter.app.resource() # set pagination limits as it'll be used by all rest interfaces set_config_data({"limits": {"pagination": 100}, "url_root": ""}) self.addCleanup(set_config_data, {})
def setUp(self): """ Mock a fake supervisor, and also a fake log and group. """ self.transaction_id = 'transaction_id' self.job_id = 'job_id' self.log = mock.MagicMock() self.group = iMock(IScalingGroup, tenant_id='tenant', uuid='group') self.state = None self.supervisor = iMock(ISupervisor) self.completion_deferred = Deferred() self.supervisor.execute_config.return_value = succeed( (self.job_id, self.completion_deferred)) def fake_modify_state(f, *args, **kwargs): return maybeDeferred( f, self.group, self.state, *args, **kwargs) self.group.modify_state.side_effect = fake_modify_state 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): """ 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): """ Configure test resources. """ self.log = mock_log() self.group = iMock(IScalingGroup) self.group.tenant_id = 11111 self.group.uuid = "group-id" self.region = "ORD" self.auth_tokens = ("auth-token1", "auth-token2", "auth-token3") self._auth_token_queue = list(self.auth_tokens) self.service_catalog = {} self.authenticator = iMock(IAuthenticator) self.auth_function = self.authenticator.authenticate_tenant self.auth_function.side_effect = lambda *a, **kw: succeed((self._auth_token_queue.pop(0), self.service_catalog)) self.fake_server_details = {"server": {"id": "server_id", "links": ["links"], "name": "meh", "metadata": {}}} self.cooperator = mock.Mock(spec=Cooperator) self.service_mapping = { ServiceType.CLOUD_SERVERS: "SUPERVISOR_CS", ServiceType.CLOUD_LOAD_BALANCERS: "SUPERVISOR_CLB", ServiceType.RACKCONNECT_V3: "SUPERVISOR_RCV3", } self.supervisor = SupervisorService( self.authenticator, self.region, self.cooperator.coiterate, self.service_mapping ) self.InMemoryUndoStack = patch(self, "otter.supervisor.InMemoryUndoStack") self.undo = self.InMemoryUndoStack.return_value self.undo.rewind.return_value = succeed(None)
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.update_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.maybe_exec_policy = patch(self, 'otter.scheduler.maybe_execute_scaling_policy') 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.otter_log = patch(self, 'otter.scheduler.otter_log') self.clock = Clock() self.scheduler_service = SchedulerService(100, 1, self.slv_client, self.clock) self.otter_log.bind.assert_called_once_with(system='otter.scheduler') self.log = self.otter_log.bind.return_value self.next_cron_occurrence = patch(self, 'otter.scheduler.next_cron_occurrence') self.next_cron_occurrence.return_value = 'newtrigger'
def test_return_values_are_assignable(self): """ Return values can be assigned both after the imock is created, and during creation via kwargs. """ im = iMock(_ITest1) im.method1.return_value = 5 self.assertEqual(im.method1(1, 2), 5) im = iMock(_ITest1, **{'method1.return_value': 'whoosit'}) self.assertEqual(im.method1(1, 2), 'whoosit')
def test_attributes_are_assignable(self): """ Attributes can be assigned both after the imock is created, and during creation via kwargs. """ im = iMock(_ITest1) im.first_attribute = "first" self.assertEqual(im.first_attribute, "first") im = iMock(_ITest1, first_attribute='whoosit') self.assertEqual(im.first_attribute, 'whoosit')
def test_extra_attributes_and_config_passed_to_mock(self): """ Any attributes and return values provided to iMock that are not specified by the interface are passed directly to :class:`MagicMock`. They can be ignored (for example if they are method return values for methods not in the original spec) or set on the imock (if they are just attributes) """ with self.assertRaises(AttributeError): # because method2 not in im = iMock(_ITest1, **{'method2.return_value': 'whoosit'}) im = iMock(_ITest1, another_attribute='what') self.assertEqual(im.another_attribute, 'what')
def test_side_effects_are_assignable(self): """ Side effects can be assigned both after the imock is created, and during creation via kwargs, and do not interfere with method signature checking. """ im = iMock(_ITest1) im.method1.side_effect = lambda *a, **kw: 5 self.assertEqual(im.method1(1, 2), 5) self.assertRaises(TypeError, 1, callableObj=im.method1) im = iMock(_ITest1, **{'method1.side_effect': lambda *a, **kw: 'meh'}) self.assertEqual(im.method1(1, 2), 'meh') self.assertRaises(TypeError, 1, callableObj=im.method1)
def test_spec_arg_is_ignored_or_passed_to_interface_if_in_attributes(self): """ If "spec" is passed, it is either ignored, or if one of the interfaces has "spec" as an attribute, the attribute is set. Either way, it is not used for speccing a Mock. """ spec = ['one', 'two', 'three'] for args in ([], [_ITest1], [_ITest3]): im = iMock(*args, spec=spec) with self.assertRaises(AttributeError): im.one im = iMock(_ITest3, spec=spec) self.assertEqual(im.spec, pvector(spec))
def test_invalidate_token(self): """Performig causes a call to authenticator.invalidate.""" mock_auth = iMock(ICachingAuthenticator) mock_auth.invalidate.return_value = None eff = Effect(InvalidateToken(mock_auth, 'tenant_id1')) self.assertEqual(sync_perform(get_simple_dispatcher(None), eff), None) mock_auth.invalidate.assert_called_once_with('tenant_id1')
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 state self.mock_state = mock.MagicMock(spec=[]) # so nothing can call it self.new_state = None def _set_new_state(new_state): self.new_state = new_state def _mock_modify_state(modifier, *args, **kwargs): d = modifier(self.mock_group, self.mock_state, *args, **kwargs) return d.addCallback(_set_new_state) self.mock_group.modify_state.side_effect = _mock_modify_state self.maybe_exec_policy = patch(self, 'otter.scheduler.maybe_execute_scaling_policy', return_value=defer.succeed('newstate')) self.log = mock.Mock() self.log_args = {'tenant_id': '1234', 'scaling_group_id': 'scal44', 'policy_id': 'pol44'} self.event = {'tenantId': '1234', 'groupId': 'scal44', 'policyId': 'pol44', 'trigger': 'now', 'cron': '*', 'bucket': 1, 'version': 'v2'}
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): """ Create WaitingAuthenticator """ self.clock = Clock() self.mock_auth = iMock(IAuthenticator) self.authenticator = WaitingAuthenticator(self.clock, self.mock_auth, 5)
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): """ 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): """ 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): """ 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': {}} } self.cooperator = mock.Mock(spec=Cooperator) self.supervisor = SupervisorService( self.auth_function, 'ORD', 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): """ 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): """ Create RetryingAuthenticator """ self.clock = Clock() self.mock_auth = iMock(IAuthenticator) self.authenticator = RetryingAuthenticator( self.clock, self.mock_auth, max_retries=3, retry_interval=4)
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 mock_group(): """ Create a mocked ScalingGroup. """ group = iMock(IScalingGroup, tenant_id='tenant', uuid='group') group.view_config.return_value = defer.succeed("config") group.get_policy.return_value = defer.succeed("policy") group.view_launch_config.return_value = defer.succeed("launch") return group
def setUp(self): """ Create sample _DeleteJob """ self.supervisor = iMock(ISupervisor) log = mock.Mock() self.job = supervisor._DeleteJob(log, "trans_id", "group", {"id": 2, "b": "lah"}, self.supervisor) log.bind.assert_called_once_with(system="otter.job.delete", server_id=2) self.log = log.bind.return_value
def setUp(self): """ Create sample _DeleteJob """ self.supervisor = iMock(ISupervisor) log = mock.Mock() self.job = supervisor._DeleteJob(log, 'trans_id', 'group', {'id': 2, 'b': 'lah'}, self.supervisor) log.bind.assert_called_once_with(system='otter.job.delete', server_id=2) self.log = log.bind.return_value
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): """ Create RetryingAuthenticator """ self.clock = Clock() self.mock_auth = iMock(IAuthenticator) self.authenticator = RetryingAuthenticator(self.clock, self.mock_auth, max_retries=3, retry_interval=4)
def test_authenticate(self): """Performing causes a call to authenticator.authenticate_tenant.""" result = ('token', {'catalog': 'foo'}) mock_auth = iMock(IAuthenticator) mock_auth.authenticate_tenant.return_value = succeed(result) log = object() eff = Effect(Authenticate(mock_auth, 'tenant_id1', log)) self.assertEqual(sync_perform(get_simple_dispatcher(None), eff), result) mock_auth.authenticate_tenant.assert_called_once_with('tenant_id1', log=log)
def setUp(self): """ Setup stub clock, treq implementation and mock authenticator """ self.clock = Clock() self.auth = iMock(IAuthenticator) self.auth.authenticate_tenant.return_value = succeed(('token', 'catalog')) self.peu = patch(self, 'otter.convergence.public_endpoint_url', return_value='url') self.req = ('GET', 'url/servers/detail?limit=10', dict(headers=headers('token'))) self.servers = [{'id': i} for i in range(9)]
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): """ Fake supervisor, group and state """ self.tid = 'trans_id' self.log = mock_log() self.group = iMock(IScalingGroup, tenant_id='tenant', uuid='group') self.state = GroupState('tid', 'gid', 'g', {'s0': {'id': 's0'}}, {}, None, None, None, desired=1) self.supervisor = FakeSupervisor() set_supervisor(self.supervisor) self.addCleanup(set_supervisor, None)
def test_imock_provides_all_the_interfaces_passed_to_it(self): """ All the attributes on all the interfaces passed to iMock are specced, and the resultant mock provides the interfaces. """ im = iMock(_ITest1, _ITest2) self.assertTrue(_ITest1.providedBy(im)) self.assertTrue(_ITest2.providedBy(im)) self.assertTrue(callable(im.method1)) self.assertTrue(callable(im.method2)) self.assertFalse(callable(im.first_attribute)) self.assertFalse(callable(im.second_attribute))
def setUp(self): """ Mock reactor and transport." """ self.reactor = iMock(IReactorUDP, IReactorCore, IReactorPluggableResolver) patch(self, 'txgraylog2.graylogger.reactor', new=self.reactor) self.transport = iMock(IUDPTransport) def listenUDP(port, proto): proto.makeConnection(self.transport) self.reactor.listenUDP.side_effect = listenUDP def callWhenRunning(f, *args, **kwargs): f(*args, **kwargs) self.reactor.callWhenRunning = callWhenRunning self.reactor.resolve.return_value = succeed('127.0.0.1') self.graylog = GraylogUDPPublisher(reactor=self.reactor)
def setUp(self): """ Configure a clock and a fake auth function. """ self.authenticator = iMock(IAuthenticator) def authenticate_tenant(tenant_id): return succeed(('auth-token', 'catalog')) self.authenticator.authenticate_tenant.side_effect = authenticate_tenant self.auth_function = self.authenticator.authenticate_tenant self.clock = Clock() self.ca = CachingAuthenticator(self.clock, self.authenticator, 10)
def test_imock_methods_have_right_signature(self): """ Passing the wrong number of arguments to methods will raise exceptions. """ im = iMock(_ITest1, _ITest2) self.assertRaises(TypeError, im.method1) self.assertRaises(TypeError, 'arg1', callableObj=im.method1) self.assertRaises(TypeError, 'arg1', 'arg2', 'arg3', 'arg4', callableObj=im.method2) self.assertRaises(TypeError, callableObj=im.method2, arg2_1='good', arg2_2='good', nonexistant='bad') im.method1('arg1', 'arg2', 'kwarg1', 'any', 'any', any='any') im.method2('arg1', 'arg2') im.method2(arg2_1='arg1', arg2_2='arg2', kwarg2_1='arg3')
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 test_imock_does_not_include_interface_methods_or_attributes(self): """ Mocking an interface produces only the attributes on the interface provided, not attributes on other interfaces and not :class:`Interface`-specific attributes and methods such as :obj:`Interface.providedBy`. """ im = iMock(_ITest1) self.assertTrue(callable(im.method1)) self.assertFalse(callable(im.first_attribute)) with self.assertRaises(AttributeError): im.providedBy(im) with self.assertRaises(AttributeError): im.second_attribute
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 the interface :return: None """ self.mock_store = iMock(IScalingGroupCollection) # mock out modify state self.mock_state = mock.MagicMock(spec=[]) # so nothing can call it self.mock_group = mock_group(self.mock_state, '11111', 'one') 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') self.otter = Otter(self.mock_store, 'ord') self.root = self.otter.app.resource() # set pagination limits as it'll be used by all rest interfaces set_config_data({'limits': {'pagination': 100}, 'url_root': ''}) self.addCleanup(set_config_data, {})
def request(self, endpoint=None, method="GET", body="", root=None): """ Make a pretend request to otter :param endpoint: what the URI in the request should be :type endpoint: ``string`` :param method: what method the request should use: "GET", "DELETE", "POST", or "PUT" :type method: ``string`` :param body: what the request body should contain :type body: ``string`` :return: :class:`ResponseWrapper` """ if root is None: if not hasattr(self, 'root'): root = Otter(iMock(IScalingGroupCollection)).app.resource() else: root = self.root return self.successResultOf( request(root, method, endpoint or self.endpoint, body=body))
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.update_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.maybe_exec_policy = patch( self, 'otter.scheduler.maybe_execute_scaling_policy') 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.otter_log = patch(self, 'otter.scheduler.otter_log') self.clock = Clock() self.scheduler_service = SchedulerService(100, 1, self.slv_client, self.clock) self.otter_log.bind.assert_called_once_with(system='otter.scheduler') self.log = self.otter_log.bind.return_value self.next_cron_occurrence = patch( self, 'otter.scheduler.next_cron_occurrence') self.next_cron_occurrence.return_value = 'newtrigger'
def get_store(self): return iMock(IScalingGroupCollection)