def test_execute(self):
actor = elb_actor.SetCert(
'Unit Test', {'name': 'unit-test',
'region': 'us-east-1',
'cert_name': 'unit-cert'}
)
elb = mock.Mock()
elb.listeners = [
(443, 443, 'HTTPS', 'HTTPS',
'arn:aws:iam::12345:server-certificate/nextdoor.com')]
actor._find_elb = helper.mock_tornado(elb)
actor._get_cert_arn = helper.mock_tornado('arn')
actor._check_access = helper.mock_tornado()
actor._use_cert = helper.mock_tornado()
yield actor._execute()
self.assertEquals(actor._check_access._call_count, 0)
self.assertEquals(actor._use_cert._call_count, 1)
# Check quick exit if the cert is already in use
actor._get_cert_arn = helper.mock_tornado(elb.listeners[0][4])
yield actor._execute()
# Function calls should remain unchanged
self.assertEquals(actor._check_access._call_count, 0)
self.assertEquals(actor._use_cert._call_count, 1)
def test_execute(self):
self.actor._dry = False
initial_array = mock.MagicMock(name='unittestarray')
self.actor._find_server_arrays = mock_tornado(initial_array)
@gen.coroutine
def update_array(array, params):
array.updated(params)
self.client_mock.update.side_effect = update_array
self.actor._terminate_all_instances = mock_tornado()
self.actor._wait_until_empty = mock_tornado()
ret = yield self.actor._execute()
# Verify that the array object would have been patched
self.client_mock.update.assert_called_once_with(
initial_array, [('server_array[state]', 'disabled')])
initial_array.updated.assert_called_once_with(
[('server_array[state]', 'disabled')])
# Now verify that each of the steps (terminate, wait, destroyed) were
# all called.
self.assertEquals(self.actor._wait_until_empty._call_count, 1)
self.assertEquals(self.actor._terminate_all_instances._call_count, 1)
self.assertEquals(ret, None)
def test_exec_not_found(self):
self.actor._client.destroy_resource = helper.mock_tornado()
self.actor._find_deployment = helper.mock_tornado(None)
with self.assertRaises(exceptions.InvalidOptions):
yield self.actor._execute()
self.assertEquals(self.actor._client.destroy_resource._call_count, 0)
def test_execute(self):
actor = sqs.WaitUntilEmpty('UTA!',
{'name': 'unit-test-queue',
'region': 'us-west-2'})
actor._wait = mock_tornado(True)
actor._fetch_queues = mock_tornado([mock.Mock()])
yield actor.execute()
def test_execute_present(self):
self.actor._ensure_mci = helper.mock_tornado(None)
self.actor._ensure_description = helper.mock_tornado(None)
self.actor._ensure_settings = helper.mock_tornado(None)
self.actor._ensure_tags = helper.mock_tornado(None)
self.actor._commit = helper.mock_tornado(None)
self.actor.changed = True
yield self.actor._execute()
def test_execute_present(self):
self.actor.changed = True
self.actor._dry = True
self.actor._commit = helper.mock_tornado(None)
self.actor._precache = helper.mock_tornado(None)
self.actor._set_description = helper.mock_tornado(None)
self.actor._set_images = helper.mock_tornado(None)
yield self.actor._execute()
def test_exec_and_wait(self):
self.client_mock.run_executable_on_instances = mock_tornado(['test'])
self.client_mock.wait_for_task = mock_tornado('success-test')
ret = yield self.actor._exec_and_wait('', {}, [], 1)
self.assertEquals(ret, 'success-test')
self.assertEquals(
self.client_mock.run_executable_on_instances._call_count, 1)
self.assertEquals(self.client_mock.wait_for_task._call_count, 1)
def test_execute_with_missing_array(self):
mocked_array = mock.MagicMock(name='unittestarray')
mocked_array.soul = {'name': 'unittestarray'}
self.actor._update_params = mock_tornado(True)
self.actor._find_server_arrays = mock_tornado(mocked_array)
ret = yield self.actor._execute()
self.assertEquals(None, ret)
def test_execute_empty(self):
actor = sqs.WaitUntilEmpty('UTA!',
{'name': 'unit-test-queue',
'region': 'us-west-2',
'required': True})
actor._wait = mock_tornado(True)
actor._fetch_queues = mock_tornado()
with self.assertRaises(sqs.QueueNotFound):
yield actor.execute()
def test_execute(self):
self.actor._dry = False
mocked_array = mock.MagicMock(name='unittestarray')
self.actor._update_params = mock_tornado(True)
self.actor._find_server_arrays = mock_tornado(mocked_array)
ret = yield self.actor._execute()
self.assertEquals(None, ret)
def test_execute_dry_with_missing_array(self):
self.actor._dry = True
mocked_array = mock.MagicMock(name='unittestarray')
mocked_array.soul = {'name': 'unittestarray'}
self.actor._check_array_inputs = mock_tornado(True)
self.actor._find_server_arrays = mock_tornado(mocked_array)
ret = yield self.actor._execute()
self.assertEquals(None, ret)
def test_exec(self):
mci = mock.MagicMock(name='unit-test-mci')
self.actor._client.find_by_name_and_keys = helper.mock_tornado(mci)
self.actor._client.show = helper.mock_tornado(mock.MagicMock())
with mock.patch.object(self.actor._client, 'destroy_resource') as dr:
dr.return_value = helper.tornado_value(1)
yield self.actor._execute()
self.assertEquals(
self.actor._client.destroy_resource._mock_call_count, 1)
def test_exec(self):
self.actor._find_deployment = helper.mock_tornado(None)
self.actor._client.find_by_name_and_keys = helper.mock_tornado(None)
self.actor._get_image_def = helper.mock_tornado('fake_mci_params')
mci_mock = mock.MagicMock(name='fake-created-mci')
with mock.patch.object(self.actor._client, 'create_resource') as cr:
cr.side_effect = helper.mock_tornado(mci_mock)
yield self.actor._execute()
self.assertEquals(cr._mock_call_count, 3)
def test_exec_dry(self):
self.actor._dry = True
self.actor._client.find_by_name_and_keys = helper.mock_tornado(None)
self.actor._get_image_def = helper.mock_tornado('fake_mci_params')
with mock.patch.object(self.actor._client, 'create_resource') as cr:
cr.return_value = 1
yield self.actor._execute()
self.assertEquals(
self.actor._client.create_resource._mock_call_count, 0)
def test_execute_dry_fail(self):
self.actor._dry = True
mock_array = mock.MagicMock(name='array')
self.actor._find_server_arrays = mock_tornado(mock_array)
# Checking script fails
self.actor._check_script = mock_tornado(False)
self.client_mock.get_server_array_current_instances = mock_tornado([])
with self.assertRaises(exceptions.InvalidOptions):
yield self.actor._execute()
def test_execute_in_dry_mode(self):
self.actor._dry = True
source_array = mock.MagicMock(name='unittestarray')
source_array.self.path = '/fo/bar/123'
self.actor._find_server_arrays = mock_tornado(source_array)
self.client_mock.update = mock_tornado()
ret = yield self.actor._execute()
self.assertEquals(None, ret)
def test_execute_dry(self):
self.actor._dry = True
mocked_array = mock.MagicMock(name='fake array')
mocked_array.soul = {'name': 'mocked-array'}
mocked_array.self.path = '/a/b/1234'
self.actor._check_array_inputs = mock_tornado(True)
self.actor._find_server_arrays = mock_tornado(mocked_array)
ret = yield self.actor._execute()
self.assertEquals(None, ret)
def setUp(self, *args, **kwargs):
super(TestDeploymentDestroyActor, self).setUp()
base.TOKEN = "unittest"
# Create the actor
self.actor = deployment.Destroy("Test", {"name": "unit-test"})
# Patch the actor so that we use the client mock
self.actor._client = mock.Mock()
self.actor._find_deployment = helper.mock_tornado(mock.MagicMock())
self.actor._client.show = helper.mock_tornado(mock.MagicMock())
def test_execute(self):
mock_array = mock.MagicMock(name='array')
mock_array.soul = {'name': 'array'}
self.actor._find_server_arrays = mock_tornado(mock_array)
self.actor._apply = mock.MagicMock()
self.actor._apply.side_effect = mock_tornado()
yield self.actor._execute()
self.actor._apply.assert_has_calls([
mock.call(self.actor._execute_array,
mock_array,
[(u'inputs[foo]', u'text:bar')])])
def test_execute(self):
actor = packagecloud.Delete(
'Unit test action',
{'packages_to_delete': 'unittest', 'repo': 'unittest'})
actor._packagecloud_client = mock.Mock()
actor._packagecloud_client.packages().http_get = mock_tornado(
ALL_PACKAGES_MOCK_RESPONSE)
actor._packagecloud_client.delete().http_delete = mock_tornado({})
deleted_packages = yield actor._execute()
self.assertEquals(deleted_packages, None)
def test_execute_concurrent(self):
mock_array = mock.MagicMock(name='array')
mock_array.soul = {'name': 'array'}
self.actor._options['concurrency'] = 2
self.actor._find_server_arrays = mock_tornado(mock_array)
self.actor._execute_array_with_concurrency = mock.MagicMock()
self.actor._execute_array_with_concurrency.side_effect = mock_tornado()
yield self.actor._execute()
self.actor._execute_array_with_concurrency.assert_has_calls([
mock.call(mock_array,
[(u'inputs[foo]', u'text:bar')])])
def test_execute(self):
actor = packagecloud.WaitForPackage(
'Unit test action',
{'name': 'unittest', 'repo': 'unittest', 'version': '0.2'})
actor._packagecloud_client = mock.Mock()
actor._packagecloud_client.packages().http_get = mock_tornado(
ALL_PACKAGES_MOCK_RESPONSE)
actor._packagecloud_client.delete().http_delete = mock_tornado({})
matched_packages = yield actor._execute()
self.assertEquals(matched_packages, None)
def test_execute_present(self):
self.actor.changed = True
self.actor.script = mock.MagicMock()
self.actor.script.soul = {
'name': 'test-script',
'description': 'test description',
'packages': 'curl'
}
self.actor.source = 'echo script1\n'
self.actor._precache = helper.mock_tornado(None)
self.actor._commit = helper.mock_tornado(None)
yield self.actor._execute()
def test_update_params_400_error(self):
# Mock out our array object, and the next_instance. Then mock out the
# api.show() method to return the mocked instance. Verify that the
# right calls were made to the API though.
mocked_array = mock.MagicMock(name='unittestarray')
mocked_instance = mock.MagicMock(name='nextinstance')
self.actor._find_def_image_href = mock_tornado('fake_href')
self.actor._client.show.side_effect = mock_tornado(mocked_instance)
error = api.RightScaleError('error')
self.client_mock.update.side_effect = error
with self.assertRaises(exceptions.RecoverableActorFailure):
yield self.actor._update_params(mocked_array)
def test_execute(self):
source_array = mock.MagicMock(name='unittestarray')
source_array.self.path = '/fo/bar/123'
self.actor._find_server_arrays = mock_tornado(source_array)
new_array = mock.MagicMock(name='unittestarray v1')
new_array.self.path = '/foo/bar/124'
self.client_mock.clone_server_array = mock_tornado(new_array)
self.client_mock.update = mock_tornado()
ret = yield self.actor._execute()
self.assertEquals(None, ret)
def test_execute_422_error(self):
mocked_array = mock.MagicMock(name='unittestarray')
self.actor._check_array_inputs = mock_tornado(True)
self.actor._find_server_arrays = mock_tornado(mocked_array)
error = api.RightScaleError('error doing thing')
self.client_mock.update.side_effect = error
with self.assertRaises(exceptions.RecoverableActorFailure):
yield self.actor._execute()
self.client_mock.update.assert_called_once_with(
mocked_array, [('server_array[name]', 'newunitarray')])
def test_execte(self):
mocked_array = mock.MagicMock(name='unittest')
mocked_array.soul = {'name': 'unittest'}
self.actor._find_server_arrays = mock_tornado(mocked_array)
self.actor._apply = mock.MagicMock(name='apply')
self.actor._apply.side_effect = mock_tornado()
yield self.actor._execute()
# Now verify that the right calls were made
self.actor._apply.assert_has_calls([
mock.call(self.actor._enable_array, mocked_array),
mock.call(self.actor._launch_instances, mocked_array, False),
mock.call(self.actor._wait_until_healthy, mocked_array),
])
def test_delete_keep_one(self):
actor = packagecloud.PackagecloudBase('Unit test action', {})
actor._packagecloud_client = mock.Mock()
actor._packagecloud_client.packages().http_get = mock_tornado(
ALL_PACKAGES_MOCK_RESPONSE)
actor._packagecloud_client.delete().http_delete = mock_tornado({})
deleted_packages = yield actor._delete(
regex='unittest', repo='unittest', number_to_keep=1)
self.assertEquals(
deleted_packages,
[{'created_at': datetime.datetime(2014, 7, 7, 20, 27, 18),
'name': 'unittest', 'distro_version': 'ubuntu/trusty',
'filename': 'unittest_0.1-1_all.deb'}])
def test_get_all_packages(self):
actor = packagecloud.PackagecloudBase('Unit test action', {})
actor._packagecloud_client = mock.Mock()
actor._packagecloud_client.packages().http_get = mock_tornado(
ALL_PACKAGES_MOCK_RESPONSE)
all_packages = yield actor._get_all_packages(repo='unittest')
self.assertEquals(all_packages, ALL_PACKAGES_MOCK_RESPONSE)
def test_execute(self):
older_than = _get_older_than()
actor = packagecloud.DeleteByDate(
'Unit test action',
{'packages_to_delete': 'unittest',
'repo': 'unittest',
'older_than': int(older_than.total_seconds())})
actor._packagecloud_client = mock.Mock()
actor._packagecloud_client.packages().http_get = mock_tornado(
ALL_PACKAGES_MOCK_RESPONSE)
actor._packagecloud_client.delete().http_delete = mock_tornado({})
deleted_packages = yield actor._execute()
self.assertEquals(deleted_packages, None)
def test_find_server_arrays_many_returned(self):
mocked_array1 = mock.MagicMock(name='mocked array1')
mocked_array2 = mock.MagicMock(name='mocked array2')
mock_find = mock_tornado([mocked_array1, mocked_array2])
self.client_mock.find_server_arrays = mock_find
ret = yield self.actor._find_server_arrays('t', raise_on='notfound')
self.assertEqual([mocked_array1, mocked_array2], ret)
def test_update_params_dry(self):
self.actor._dry = True
# Mock out our array object, and the next_instance. Then mock out the
# api.show() method to return the mocked instance. Verify that the
# right calls were made to the API though.
mocked_array = mock.MagicMock(name='unittestarray')
mocked_instance = mock.MagicMock(name='nextinstance')
self.actor._find_def_image_href = mock_tornado('fake_href')
self.actor._client.show.side_effect = mock_tornado(mocked_instance)
self.actor._client.update.side_effect = mock_tornado(True)
yield self.actor._update_params(mocked_array)
self.client_mock.show.assert_has_calls([
mock.call(mocked_array.next_instance),
])
self.assertFalse(self.client_mock.update.called)
def test_delete_keep_one(self):
actor = packagecloud.PackagecloudBase('Unit test action', {})
actor._packagecloud_client = mock.Mock()
actor._packagecloud_client.packages().http_get = mock_tornado(
ALL_PACKAGES_MOCK_RESPONSE)
actor._packagecloud_client.delete().http_delete = mock_tornado({})
deleted_packages = yield actor._delete(regex='unittest',
repo='unittest',
number_to_keep=1)
self.assertEquals(
deleted_packages,
[{
'created_at': datetime.datetime(2014, 7, 7, 20, 27, 18),
'name': 'unittest',
'distro_version': 'ubuntu/trusty',
'filename': 'unittest_0.1-1_all.deb'
}])
def test_execute_data_json(self):
actor = misc.GenericHTTP('Unit Test Action', {
'url': 'http://example.com',
'data-json': {
'foo': 'bar'
}
})
actor._fetch = mock_tornado({'success': {'code': 200}})
yield actor.execute()
def test_get_group_too_many_results(self):
matching_group = {
'name': 'unittest',
'id': 'bogus',
}
self.actor._list_groups = mock_tornado(
[matching_group, matching_group])
with self.assertRaises(exceptions.InvalidOptions):
yield self.actor._get_group()
def test_execute_dry(self):
actor = misc.GenericHTTP('Unit Test Action',
{'url': 'http://example.com'},
dry=True)
actor._fetch = mock_tornado()
yield actor.execute()
self.assertEqual(actor._fetch._call_count, 0)
def test_execute(self):
# Mock out the array calls. Make sure that a fake array is returned
mock_array = mock.MagicMock(name='mockarray')
mock_array.soul = {'name': 'mockarray'}
mock_array.href = '/href'
self.actor._find_server_arrays = helper.mock_tornado(mock_array)
# Now, mock out the find_alert_spec call
mock_alert = mock.MagicMock(name='unittest')
mock_alert.soul = {'name': 'mockalert'}
self.actor._find_alert_spec = helper.mock_tornado([mock_alert])
# Finally, mock out the destroy_resource call
destroy_mock = helper.mock_tornado([])
self.client_mock.destroy_resource = destroy_mock
# Do it!
yield self.actor._execute()
self.assertEquals(1, destroy_mock._call_count)
def test_ensure_mci_is_present_and_would_create(self):
new_mci = mock.MagicMock(name='new_mci')
self.actor._options['state'] = 'present'
self.actor._get_mci = helper.mock_tornado(None)
self.actor._create_mci = mock.MagicMock(name='create_mci')
self.actor._create_mci.side_effect = [helper.tornado_value(new_mci)]
ret = yield self.actor._ensure_mci()
self.assertEquals(new_mci, ret)
self.assertTrue(self.actor._create_mci.called)
def test_ensure_mci_is_absent_but_is_present(self):
existing_mci = mock.MagicMock(name='existing_mci')
self.actor._options['state'] = 'absent'
self.actor._get_mci = helper.mock_tornado(existing_mci)
self.actor._delete_mci = mock.MagicMock(name='delete_mci')
self.actor._delete_mci.side_effect = [helper.tornado_value(None)]
ret = yield self.actor._ensure_mci()
self.assertEquals(None, ret)
self.assertTrue(self.actor._delete_mci.called)
def test_launch_instances(self):
array_mock = mock.MagicMock(name='unittest')
array_mock.soul = {
'name': 'unittest',
'elasticity_params': {
'bounds': {
'max_count': '4'
}
}
}
launch = mock_tornado()
self.client_mock.launch_server_array.side_effect = launch
# Regular function call
self.client_mock.get_server_array_current_instances = mock_tornado([])
self.client_mock.launch_server_array.reset_mock()
yield self.actor._launch_instances(array_mock)
self.assertEquals(1, self.client_mock.launch_server_array.call_count)
self.client_mock.launch_server_array.assert_has_calls(
[mock.call(array_mock, count=4)])
# Regular function call with some servers already existing.
self.client_mock.get_server_array_current_instances = mock_tornado(
[1, 2])
self.client_mock.launch_server_array.reset_mock()
yield self.actor._launch_instances(array_mock)
self.client_mock.launch_server_array.assert_has_calls(
[mock.call(array_mock, count=2)])
# Regular function call more arrays than max_count
self.client_mock.get_server_array_current_instances = mock_tornado(
[1, 2, 3, 4, 5])
self.client_mock.launch_server_array.reset_mock()
yield self.actor._launch_instances(array_mock)
self.assertEquals(self.client_mock.launch_server_array.call_count, 0)
# Dry call
self.actor._dry = True
self.client_mock.launch_server_array.reset_mock()
yield self.actor._launch_instances(array_mock)
self.client_mock.launch_server_array.assert_has_calls([])
def test_execute_dry(self):
actor = elb_actor.SetCert('Unit Test', {
'name': 'unit-test',
'region': 'us-east-1',
'cert_name': 'unit-cert'
},
dry=True)
elb = mock.Mock()
elb.listeners = [(443, 443, 'HTTPS', 'HTTPS',
'arn:aws:iam::12345:server-certificate/nextdoor.com')
]
actor._find_elb = helper.mock_tornado(elb)
actor._get_cert_arn = helper.mock_tornado('arn')
actor._check_access = helper.mock_tornado()
yield actor._execute()
self.assertEqual(actor._check_access._call_count, 1)
def test_execute(self):
self.actor._dry = False
mocked_array = mock.MagicMock(name='unittestarray')
self.actor._check_array_inputs = mock_tornado(True)
self.actor._find_server_arrays = mock_tornado(mocked_array)
self.client_mock.update.return_value = tornado_value(None)
self.client_mock.update_server_array_inputs.return_value = (
tornado_value(None))
ret = yield self.actor._execute()
self.client_mock.update.assert_called_once_with(
mocked_array, [('server_array[name]', 'newunitarray')])
self.client_mock.update_server_array_inputs.assert_called_once_with(
mocked_array, [('inputs[test]', 'text:test')])
self.assertEqual(None, ret)
def test_precache(self):
fake_group = {
'name': 'unittest',
'id': 'bogus',
'group': {
'capacity': {
'target': 128
}
}
}
self.actor._get_group = mock_tornado(fake_group)
self.actor._validate_group = mock_tornado(None)
yield self.actor._precache()
# First make sure we stored the group
self.assertEquals(fake_group, self.actor._group)
# Second, make sure we overwrote the user config's [capacity][target]
# setting with the spotinst value
self.assertEquals(self.actor._config['group']['capacity']['target'],
128)
def test_execute_self(self):
actor = elbv2_actor.DeregisterInstance('UTA', {
'target_group': 'elb-test',
'region': 'us-east-1'})
actor._find_target_group = mock.Mock()
actor._find_target_group.return_value = helper.tornado_value('arn')
actor._get_meta_data = helper.mock_tornado('i-test')
actor._remove = mock.Mock()
actor._remove.return_value = helper.tornado_value(mock.Mock())
yield actor._execute()
actor._remove.assert_called_with('arn', ['i-test'])
def test_check_name(self):
actor = pingdom.PingdomBase('Unit Test Action', {'name': 'lollipop'})
actor._pingdom_client = mock.Mock()
actor._pingdom_client.checks().http_get = mock_tornado(
{'checks': [{
'name': 'lollipop'
}]})
check = yield actor._get_check()
self.assertEquals(check['name'], 'lollipop')
def test_find_server_arrays_dry_not_found(self):
self.client_mock.find_server_arrays = mock_tornado(None)
self.actor._dry = True
# With allow_mock enabled, we should receive a mock back
ret = yield self.actor._find_server_arrays('t', allow_mock=True)
self.assertTrue(isinstance(ret, mock.MagicMock))
# With it set to false, we should raise an exception
with self.assertRaises(exceptions.ActorException):
yield self.actor._find_server_arrays('t', allow_mock=False)
def test_execute_dry(self):
self.actor._dry = True
initial_array = mock.MagicMock(name='unittestarray')
self.actor._find_server_arrays = mock_tornado(initial_array)
@gen.coroutine
def update_array(array, params):
array.updated(params)
self.client_mock.update.side_effect = update_array
# ensure that we never called the update_array method!
yield self.actor._execute()
initial_array.updated.assert_has_calls([])
def test_execute_dry(self):
# Mock out the calls to SlackAPI.auth_test().auth_test()
auth_test_mock = mock.MagicMock(name='auth_test')
auth_test_mock.http_post.side_effect = mock_tornado({'ok': 'true'})
self._slack_mock.auth_test.return_value = auth_test_mock
# Ensure we're dry
self.actor._dry = True
ret = yield self.actor._execute()
self.assertEqual(None, ret)
# Ensure the calls were made to the API
auth_test_mock.http_post.assert_has_calls([mock.call()])
def test_get_operational_instances_warn(self):
mock_array = mock.MagicMock(name='array')
mock_op_instance = mock.MagicMock(name='mock_instance')
mock_op_instance.soul = {'state': 'operational'}
mock_non_op_instance = mock.MagicMock(name='mock_instance')
mock_non_op_instance.soul = {'state': 'booting'}
get = mock_tornado(
[mock_op_instance, mock_non_op_instance, mock_op_instance])
self.client_mock.get_server_array_current_instances = get
ret = yield self.actor._get_operational_instances(mock_array)
self.assertEquals(2, len(ret))
def test_execute_array(self):
mock_array = mock.MagicMock(name='array')
mock_op_instance = mock.MagicMock(name='mock_instance')
mock_op_instance.soul = {
'state': 'operational',
'name': 'unit-test-instance'
}
mock_task = mock.MagicMock(name='mock_task')
yi = tornado_value([mock_op_instance])
self.client_mock.get_server_array_current_instances.return_value = yi
run_e = tornado_value([(mock_op_instance, mock_task)])
self.client_mock.run_executable_on_instances.return_value = run_e
wait = tornado_value(True)
self.client_mock.wait_for_task.return_value = wait
# Now verify that each of the expected steps were called in a
# successful execution.
ret = yield self.actor._execute_array(mock_array, 1)
(self.client_mock.get_server_array_current_instances.
assert_called_twice_with(mock_array))
(self.client_mock.run_executable_on_instances.assert_called_once_with(
'test_script', 1, [mock_op_instance]))
self.client_mock.wait_for_task.assert_called_with(
task=mock_task,
task_name=('Executing "test_script" '
'on instance: unit-test-instance'),
sleep=5,
loc_log=self.actor.log,
instance=mock_op_instance)
self.assertEquals(ret, None)
# Now mock out a failure of the script execution
wait = mock_tornado(False)
self.client_mock.wait_for_task = wait
self.client_mock.get_audit_logs.side_effect = [
tornado_value(False),
tornado_value(['logs'])
]
with self.assertRaises(server_array.TaskExecutionFailed):
yield self.actor._execute_array(mock_array, 1)
# Finally, a test that mocks out an http error on bad inputs
error = api.ServerArrayException()
self.client_mock.run_executable_on_instances.side_effect = error
with self.assertRaises(exceptions.RecoverableActorFailure):
yield self.actor._execute_array(mock_array, 1)
def test_execute(self):
# Mock out the calls to SlackAPI.chat_postMessage().http_post()
post_mock = mock.MagicMock()
post_mock.http_post.side_effect = mock_tornado({'ok': 'true'})
self._slack_mock.chat_postMessage.return_value = post_mock
ret = yield self.actor._execute()
self.assertEqual(None, ret)
# Ensure the calls were made to the API
post_mock.http_post.assert_has_calls([mock.call(
username='******', unfurl_links=True, text='Unittest',
unfurl_media=True, parse='none', link_names=1, channel='#testing'
)])
def test_search(self):
actor = packagecloud.WaitForPackage('Unit test action', {
'name': 'unittest',
'repo': 'unittest',
'version': '0.2'
})
actor._packagecloud_client = mock.Mock()
actor._packagecloud_client.packages().http_get = mock_tornado(
ALL_PACKAGES_MOCK_RESPONSE)
matched_packages = yield actor._search(repo='unittest',
name='unittest',
version='0.2')
self.assertEquals(matched_packages, [ALL_PACKAGES_MOCK_RESPONSE[0]])
def test_execute_dry(self):
actor = pingdom.Pause('Unit Test Action', {'name': 'lollipop'},
dry=True)
actor._pingdom_client = mock.Mock()
actor._get_check = mock_tornado({
'name': 'lollipop',
'hostname': 'http://lollipop.com',
'id': 'lol'
})
yield actor._execute()
self.assertEquals(actor._get_check._call_count, 1)
actor._pingdom_client.check().http_put.assert_not_called()
def test_set_state_present(self):
fake_ret = {
'ok': True,
'response': {
'items': [
{'desc': 'new group'}
]
}
}
mock_client = mock.MagicMock()
mock_client.http_post.return_value = tornado_value(fake_ret)
self.actor._client.aws.ec2.create_group = mock_client
# Mock out the _get_group method which is called again after the
# create_group API call is made.
self.actor._get_group = mock_tornado(None)
# Mock out the call to our wait_until_stable() call since thats not in
# the scope of this test.
self.actor._wait_until_stable = mock_tornado(None)
yield self.actor._set_state()
mock_client.http_post.assert_called_with(
group=self.actor._config['group'])
def test_execute_with_sleep(self):
actor = packagecloud.WaitForPackage('Unit test action', {
'name': 'not_found',
'repo': 'unittest',
'version': '0.2',
'sleep': 1
})
actor._packagecloud_client = mock.Mock()
actor._packagecloud_client.packages().http_get = mock_tornado(
ALL_PACKAGES_MOCK_RESPONSE)
actor._search = mock.Mock(
side_effect=[tornado_value([]),
tornado_value(['something'])])
yield actor._execute()
self.assertEquals(actor._search.call_count, 2)
def test_execute_dry(self):
# Mock out the array calls. Make sure that a fake array is returned
mock_array = mock.MagicMock(name='mockarray')
mock_array.soul = {'name': 'mockarray'}
mock_array.href = '/href'
self.actor._find_server_arrays = helper.mock_tornado(mock_array)
# Mock the create_resource() call so we don't really try to do work
mock_create_res = mock.MagicMock(name='create_resource')
mock_create_res.return_value = helper.tornado_value()
self.actor._client.create_resource = mock_create_res
# Do it, then check the mock calls
self.actor._dry = True
yield self.actor._execute()
mock_create_res.assert_has_calls([])
def test_find_server_arrays_not_found(self):
self.client_mock.find_server_arrays = mock_tornado()
# If the array is not found, but we do want it found, it should
# raise an exception.
with self.assertRaises(exceptions.ActorException):
yield self.actor._find_server_arrays('t', raise_on='notfound')
# If the array is not found, and we don't want it found, it should
# return properly.
ret = yield self.actor._find_server_arrays('t', raise_on='found')
self.assertEquals(None, ret)
# Lastly, if the array is not found and we don't care whether its
# found or not, None should be returned
ret = yield self.actor._find_server_arrays('t', raise_on=None)
self.assertEquals(None, ret)
def test_execute_exc_500(self):
# Mock out the array calls. Make sure that a fake array is returned
mock_array = mock.MagicMock(name='mockarray')
mock_array.soul = {'name': 'mockarray'}
mock_array.href = '/href'
self.actor._find_server_arrays = helper.mock_tornado(mock_array)
# Mock the create_resource() call so we don't really try to do work
msg = '500: Unknown error'
mocked_response = mock.MagicMock(name='response')
mocked_response.status_code = 500
exc = requests.exceptions.HTTPError(msg, response=mocked_response)
self.actor._client.create_resource.side_effect = exc
# Do it, then check the mock calls
with self.assertRaises(requests.exceptions.HTTPError):
yield self.actor._execute()
def test_execute_self(self):
# No instance id specified
act = elb_actor.DeregisterInstance('UTA', {
'elb': 'elb-test',
'region': 'us-east-1'
})
act._find_elb = mock.Mock()
act._find_elb.return_value = helper.tornado_value(mock.Mock())
act._remove = mock.Mock()
act._remove.return_value = helper.tornado_value(mock.Mock())
act._get_meta_data = helper.mock_tornado('i-test')
yield act._execute()
act._find_elb.assert_called_with('elb-test')
lb = yield act._find_elb()
act._remove.assert_called_with(lb, ['i-test'])
def test_execute(self):
misc.Macro._check_macro = mock.Mock()
misc.Macro._get_macro = mock.Mock()
misc.Macro._get_config_from_script = mock.Mock()
misc.Macro._get_config_from_script.return_value = {}
misc.Macro._check_schema = mock.Mock()
with mock.patch('kingpin.actors.utils.get_actor') as get_actor:
actor = misc.Macro('Unit Test', {'macro': 'test.json',
'tokens': {}},
dry=True)
get_actor().execute = mock_tornado()
yield actor._execute()
self.assertEqual(get_actor().execute._call_count, 1)
