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):
"""
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 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 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 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):
"""
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):
"""
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):
"""
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):
"""
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):
"""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 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()
