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 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 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 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):
"""
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):
"""
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):
"""
Create WaitingAuthenticator
"""
self.clock = Clock()
self.mock_auth = iMock(IAuthenticator)
self.authenticator = WaitingAuthenticator(self.clock, self.mock_auth,
5)
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 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):
"""
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)
