예제 #1
0
    def test_generate_bindings(self):
        binding_a_mocked_res_rev_0 = mock.MagicMock(name='binding_a')
        binding_a_mocked_res_rev_0.href = '/api/binding/binding_a_rev_0'
        binding_a_mocked_res_rev_0.soul = {'revision': 0}

        binding_a_mocked_res_rev_1 = mock.MagicMock(name='binding_a')
        binding_a_mocked_res_rev_1.href = '/api/binding/binding_a_rev_1'
        binding_a_mocked_res_rev_1.soul = {'revision': 1}

        binding_b_mocked_res = mock.MagicMock(name='binding_b')
        binding_b_mocked_res.href = '/api/binding/binding_b_rev_0'
        binding_b_mocked_res.soul = {'revision': 0}

        self.client_mock.find_by_name_and_keys.side_effect = [
            # The first call will look for script A and get a list of results
            # back. One will match, the others wont.
            helper.tornado_value([
                binding_a_mocked_res_rev_0, binding_a_mocked_res_rev_1]),

            # The second call will actually get back a single result thats not
            # in a list. It will match what we're looking for
            helper.tornado_value(binding_b_mocked_res),
        ]

        ret = yield self.actor._generate_bindings(
            self.actor.option('boot_bindings'), 'boot')
        self.assertEquals(
            [
                {'position': 1,
                 'right_script_href': '/api/binding/binding_a_rev_0',
                 'sequence': 'boot'},
                {'position': 2,
                 'right_script_href': '/api/binding/binding_b_rev_0',
                 'sequence': 'boot'},
            ], ret)
예제 #2
0
    def test_precache(self):
        # Generate new ST and Tag mocks
        new_st = mock.MagicMock(name='new_st')
        boot_binding_c = mock.MagicMock(name='bootC')
        new_tags = ['tag3']

        # Used when searching for the server template
        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value(new_st)
        ]

        self.client_mock.show.side_effect = [
            helper.tornado_value(boot_binding_c)
        ]

        self.actor._get_resource_tags = mock.MagicMock()
        self.actor._get_resource_tags.side_effect = [
            helper.tornado_value(new_tags)
        ]

        with mock.patch.object(alerts, 'AlertSpecsBase') as a_mock:
            a_mock()._precache.side_effect = [
                helper.tornado_value(None)]

            yield self.actor._precache()
            self.assertEquals(self.actor.alert_specs, a_mock())
        self.assertEquals(self.actor.st, new_st)
        self.assertEquals(self.actor.desired_images, {})
        self.assertEquals(self.actor.tags, new_tags)
예제 #3
0
    def test_generate_bindings_missing_revision(self):
        binding_a_mocked_res_rev_2 = mock.MagicMock(name='binding_a')
        binding_a_mocked_res_rev_2.href = '/api/binding/binding_a_rev_2'
        binding_a_mocked_res_rev_2.soul = {'revision': 2}

        binding_a_mocked_res_rev_1 = mock.MagicMock(name='binding_a')
        binding_a_mocked_res_rev_1.href = '/api/binding/binding_a_rev_1'
        binding_a_mocked_res_rev_1.soul = {'revision': 1}

        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value([
                binding_a_mocked_res_rev_2, binding_a_mocked_res_rev_1]),
        ]

        with self.assertRaises(exceptions.InvalidOptions):
            yield self.actor._generate_bindings(
                self.actor.option('boot_bindings'), 'boot')

        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value(binding_a_mocked_res_rev_2)
        ]

        with self.assertRaises(exceptions.InvalidOptions):
            yield self.actor._generate_bindings(
                self.actor.option('boot_bindings'), 'boot')
예제 #4
0
    def test_set_bindings(self):
        binding_c = mock.MagicMock('binding_c')
        binding_c.href = '/api/binding/C'

        self.actor.boot_bindings = [
            binding_c
        ]
        self.client_mock.destroy_resource.side_effect = [
            helper.tornado_value(None)
        ]
        self.client_mock.create_resource.side_effect = [
            helper.tornado_value(None)
        ]

        yield self.actor._set_bindings(
            self.actor.desired_boot_bindings,
            self.actor.boot_bindings,
            'boot')

        self.client_mock.destroy_resource.assert_has_calls(
            mock.call(self.actor.boot_bindings[0]),
        )
        self.client_mock.create_resource.assert_has_calls([
            mock.call(
                self.actor.st.runnable_bindings,
                [('runnable_binding[right_script_href]', '/api/binding/bootA'),
                 ('runnable_binding[sequence]', 'boot')]),
            mock.call(
                self.actor.st.runnable_bindings,
                [('runnable_binding[right_script_href]', '/api/binding/bootB'),
                 ('runnable_binding[sequence]', 'boot')]),
        ])

        self.assertTrue(self.actor.changed)
예제 #5
0
    def test_ensure_mci_default(self):
        self.actor.st.links['default_multi_cloud_image'] = 'invalid'

        st_mci_a = mock.MagicMock(name='st_mci_a')
        st_mci_a.links = {
            'self': '/api/server_template_multi_cloud_image/A',
            'multi_cloud_image': '/api/multi_cloud_images/imageA'
        }
        st_mci_b = mock.MagicMock(name='st_mci_b')
        st_mci_b.links = {
            'self': '/api/server_template_multi_cloud_image/B',
            'multi_cloud_image': '/api/multi_cloud_images/imageB'
        }

        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value([st_mci_a, st_mci_b])
        ]

        self.client_mock.make_generic_request.side_effect = [
            helper.tornado_value(None)]

        yield self.actor._ensure_mci_default()

        self.client_mock.make_generic_request.assert_has_calls([
            mock.call(
                '/api/server_template_multi_cloud_image/A/make_default',
                post=[])
        ])
예제 #6
0
    def test_set_config(self):
        # First, lets copy the desired configuration blob. The first test,
        # we'll copy the blob and we'll ensure that they are the same.
        self.actor._group = copy.deepcopy(self.actor._config)

        # Insert some fake data that would normally have been returned in the
        # included blob from Spotinst.
        self.actor._group['group']['id'] = 'sig-1234123'
        self.actor._group['group']['createdAt'] = 'timestamp'
        self.actor._group['group']['updatedAt'] = 'timestamp'

        # Pretend to roll the group if a change is made
        self.actor._options['roll_on_change'] = True
        self.actor._roll_group = mock.MagicMock()
        self.actor._roll_group.return_value = tornado_value(None)

        # Mock out the update_group call..
        fake_ret = {
            'response': {
                'items': [
                    {'group': 'object'}
                ]
            }
        }
        mock_client = mock.MagicMock()
        mock_client.http_put.return_value = tornado_value(fake_ret)
        self.actor._client.aws.ec2.update_group.return_value = mock_client

        yield self.actor._set_config()

        mock_client.http_put.assert_called_with(
            group=self.actor._config['group'])
        self.assertEquals(self.actor._group['group'], {'group': 'object'})
        self.actor._roll_group.assert_has_calls([mock.call])
예제 #7
0
    def test_ensure_template_exc(self):
        self.actor._create_change_set = mock.MagicMock(name='_create_change')
        self.actor._create_change_set.return_value = tornado_value(
            {'Id': 'abcd'})
        self.actor._wait_until_change_set_ready = mock.MagicMock(name='_wait')
        self.actor._wait_until_change_set_ready.return_value = tornado_value(
            {'Changes': []})
        self.actor._execute_change_set = mock.MagicMock(name='_execute_change')
        fake_exc = {
            'ResponseMetadata': {
                'HTTPStatusCode': 400,
                'RequestId': 'dfc1a12c-22c1-11e6-80b1-8fd4cf167f54'
            },
            'Error': {
                'Message': 'Template format error: JSON not well-formed',
                'Code': 'ValidationError',
                'Type': 'Sender'
            }
        }
        self.actor._execute_change_set.side_effect = ClientError(
            fake_exc, 'FakeOperation')

        fake_stack = create_fake_stack('fake', 'CREATE_COMPLETE')

        # Grab the raw stack body from the test actor -- this is what it should
        # compare against, so this test should cause the method to bail out and
        # not make any changes.
        template = {'Fake': 'Stack'}
        get_temp_mock = mock.MagicMock(name='_get_stack_template')
        self.actor._get_stack_template = get_temp_mock
        self.actor._get_stack_template.return_value = tornado_value(template)

        # Ensure we raise an exception if something bad happens
        with self.assertRaises(cloudformation.StackFailed):
            yield self.actor._ensure_template(fake_stack)
예제 #8
0
 def test_get_mci_setting_def_exc_in_instance_call(self):
     # First, mock out a correct set of responses where we succeed in
     # finding the cloud, image and instance HREFs.
     self.client_mock.find_by_name_and_keys.side_effect = [
         helper.tornado_value(self.clouda_mock),
         helper.tornado_value(self.clouda_image_mock),
         helper.tornado_value(None)
     ]
     with self.assertRaises(exceptions.InvalidOptions):
         yield self.actor._get_mci_setting_def(self._images[0])
예제 #9
0
 def test_get_mci_setting_def_no_user_data(self):
     # First, mock out a correct set of responses where we succeed in
     # finding the cloud, image and instance HREFs.
     self.client_mock.find_by_name_and_keys.side_effect = [
         helper.tornado_value(self.cloudb_mock),
         helper.tornado_value(self.cloudb_image_mock),
         helper.tornado_value(self.cloudb_instance_mock),
     ]
     ret = yield self.actor._get_mci_setting_def(self._images[1])
     self.assertEquals(ret, self.cloudb_href_tuples)
예제 #10
0
    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'])
예제 #11
0
    def test_execute(self):
        actor = elbv2_actor.RegisterInstance('UTA', {
            'target_group': 'test',
            'region': 'us-east-1',
            'instances': 'i-test'})

        actor._find_target_group = mock.Mock()
        actor._find_target_group.return_value = helper.tornado_value('arn')
        actor._add = mock.Mock()
        actor._add.return_value = helper.tornado_value(mock.Mock())
        yield actor._execute()
        actor._add.assert_called_with('arn', ['i-test'])
예제 #12
0
 def test_execute(self):
     actor = cloudformation.Delete(
         'Unit Test Action',
         {'name': 'unit-test-cf',
          'region': 'us-west-2'})
     actor._get_stack = mock.MagicMock(name='_get_stack')
     actor._get_stack.return_value = tornado_value(True)
     actor._delete_stack = mock.MagicMock(name='_delete_stack')
     actor._delete_stack.return_value = tornado_value(None)
     actor._wait_until_state = mock.MagicMock(name='_wait_until_state')
     actor._wait_until_state.side_effect = cloudformation.StackNotFound()
     yield actor._execute()
예제 #13
0
    def test_precache_empty(self):
        fake_script = mock.MagicMock(name='FakeScript')
        fake_script.soul = {'name': 'FakeScript'}

        # Now create a fake Rightscale resource collection object and make sure
        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value(None)]
        self.client_mock.make_generic_request.side_effect = [
            helper.tornado_value(None)]
        yield self.actor._precache()
        self.assertEquals(None, self.actor.script)
        self.assertEquals(None, self.actor.source)
예제 #14
0
    def test_ensure_stack_is_absent_and_wants_present(self):
        self.actor._options['state'] = 'present'
        self.actor._get_stack = mock.MagicMock(name='_get_stack')
        self.actor._get_stack.return_value = tornado_value(None)
        self.actor._delete_stack = mock.MagicMock(name='_delete_stack')
        self.actor._delete_stack.return_value = tornado_value(None)
        self.actor._create_stack = mock.MagicMock(name='_create_stack')
        self.actor._create_stack.return_value = tornado_value(None)

        yield self.actor._ensure_stack()

        self.assertFalse(self.actor._delete_stack.called)
        self.assertTrue(self.actor._create_stack.called)
예제 #15
0
 def test_update_stack_in_failed_state(self):
     fake_stack = create_fake_stack('fake', 'CREATE_FAILED')
     self.actor._get_stack = mock.MagicMock(name='_get_stack')
     self.actor._get_stack.return_value = tornado_value(fake_stack)
     self.actor._delete_stack = mock.MagicMock(name='_delete_stack')
     self.actor._delete_stack.return_value = tornado_value(fake_stack)
     self.actor._create_stack = mock.MagicMock(name='_create_stack')
     self.actor._create_stack.return_value = tornado_value(fake_stack)
     yield self.actor._update_stack(fake_stack)
     self.actor._delete_stack.assert_called_with(
         stack='arn:aws:cloudformation:us-east-1:xxxx:stack/fake/x')
     self.actor._create_stack.assert_called_with(
         stack='fake')
예제 #16
0
 def test_delete_mci(self):
     mci = mock.MagicMock(name='mci')
     self.client_mock.find_by_name_and_keys.side_effect = [
         helper.tornado_value(mci)
     ]
     self.client_mock.destroy_resource.side_effect = [
         helper.tornado_value(None)
     ]
     ret = yield self.actor._delete_mci(name='mci')
     self.assertEquals(ret, None)
     self.client_mock.destroy_resource.assert_has_calls([
         mock.call(mci)
     ])
예제 #17
0
    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)
예제 #18
0
    def test_ensure_stack_is_present_and_wants_absent(self):
        self.actor._options['state'] = 'absent'
        fake_stack = create_fake_stack('unit-test-cf', 'CREATE_COMPLETE')
        self.actor._get_stack = mock.MagicMock(name='_get_stack')
        self.actor._get_stack.return_value = tornado_value(fake_stack)
        self.actor._delete_stack = mock.MagicMock(name='_delete_stack')
        self.actor._delete_stack.return_value = tornado_value(None)
        self.actor._create_stack = mock.MagicMock(name='_create_stack')
        self.actor._create_stack.return_value = tornado_value(None)

        yield self.actor._ensure_stack()

        self.assertTrue(self.actor._delete_stack.called)
        self.assertFalse(self.actor._create_stack.called)
예제 #19
0
    def test_execute(self):

        actor = elb_actor.WaitUntilHealthy(
            'Unit Test Action', {'name': 'unit-test-queue',
                                 'region': 'us-west-2',
                                 'count': 3})

        actor._find_elb = mock.Mock(return_value=helper.tornado_value('ELB'))
        actor._is_healthy = mock.Mock(return_value=helper.tornado_value(True))

        val = yield actor._execute()
        self.assertEquals(actor._find_elb.call_count, 1)
        self.assertEquals(actor._is_healthy.call_count, 1)
        self.assertEquals(val, None)
예제 #20
0
    def test_wait_until_state_stack_failed(self):
        create_in_progress = create_fake_stack('test', 'CREATE_IN_PROGRESS')
        create_complete = create_fake_stack('test', 'CREATE_COMPLETE')

        # Make sure a cloudformationerror is raised if we ask for a deleted
        # state rather than a created one.
        self.actor._get_stack = mock.MagicMock(name='FakeStack')
        self.actor._get_stack.side_effect = [
            tornado_value(create_in_progress),
            tornado_value(create_in_progress),
            tornado_value(create_complete)
        ]
        with self.assertRaises(cloudformation.StackFailed):
            yield self.actor._wait_until_state(
                'test', cloudformation.DELETED, sleep=0.1)
예제 #21
0
    def test_update_stack_ensure_termination_protection_true_to_true(self):
        fake_stack = create_fake_stack('fake', 'CREATE_COMPLETE')
        fake_stack['EnableTerminationProtection'] = True
        self.actor._options['enable_termination_protection'] = True

        self.actor._update_termination_protection = mock.MagicMock(
            name='_update_termination_protection')
        self.actor._update_termination_protection.return_value = tornado_value(
            None)

        self.actor._ensure_template = mock.MagicMock(name='_ensure_stack')
        self.actor._ensure_template.return_value = tornado_value(None)

        yield self.actor._update_stack(fake_stack)
        self.assertFalse(self.actor._update_termination_protection.called)
예제 #22
0
    def test_execute(self):
        act = elb_actor.DeregisterInstance('UTA', {
            'elb': 'elb-test',
            'region': 'us-east-1',
            'instances': 'i-test'})

        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())
        yield act._execute()

        act._find_elb.assert_called_with('elb-test')
        lb = yield act._find_elb()
        act._remove.assert_called_with(elb=lb, instances=['i-test'])
예제 #23
0
    def test_execute_wildcard(self):
        act = elb_actor.DeregisterInstance('UTA', {
            'elb': '*',
            'region': 'us-east-1',
            'instances': 'i-test'})

        act._find_instance_elbs = mock.Mock()
        act._find_instance_elbs.return_value = helper.tornado_value(
            [mock.Mock()])
        act._remove = mock.Mock()
        act._remove.return_value = helper.tornado_value(mock.Mock())

        yield act._execute()

        act._find_instance_elbs.assert_called_with(['i-test'])
예제 #24
0
    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)
예제 #25
0
 def test_generate_bindings_empty_result(self):
     self.client_mock.find_by_name_and_keys.side_effect = [
         helper.tornado_value([])
     ]
     with self.assertRaises(exceptions.InvalidOptions):
         yield self.actor._generate_bindings(
             self.actor.option('boot_bindings'), 'boot')
예제 #26
0
 def test_ensure_mci_default_no_default_selected(self):
     self.actor._dry = True
     self.client_mock.find_by_name_and_keys.side_effect = [
         helper.tornado_value([])]
     di = self.actor.desired_images['/api/multi_cloud_images/imageA']
     di['default'] = False
     yield self.actor._ensure_mci_default()
예제 #27
0
 def test_set_alerts(self):
     self.actor.alert_specs = mock.MagicMock()
     self.actor.alert_specs.execute.side_effect = [
         helper.tornado_value(None)]
     yield self.actor._set_alerts()
     self.assertTrue(self.actor.changed)
     self.assertTrue(self.actor.alert_specs.execute.called)
예제 #28
0
    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(elb=lb, instances=['i-test'])
예제 #29
0
 def test_create_st(self):
     new_st = mock.MagicMock(name='new_st')
     self.client_mock.create_resource.side_effect = [
         helper.tornado_value(new_st)
     ]
     yield self.actor._create_st()
     self.assertEquals(self.actor.st, new_st)
예제 #30
0
 def test_set_description(self):
     new_st = mock.MagicMock(name='new_st')
     self.client_mock.update.side_effect = [
         helper.tornado_value(new_st)
     ]
     yield self.actor._set_description()
     self.assertEquals(new_st, self.actor.st)
예제 #31
0
    def test_get_mci_href(self):
        self.actor.desired_images = {}

        mci_mock = mock.MagicMock(name='returned_mci')
        mci_mock.href = '/api/multi_cloud_images/test'

        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value(mci_mock)
        ]
        yield self.actor._get_mci_href({'mci': 'test mci'})
        self.assertEqual(self.actor.desired_images,
                         {'/api/multi_cloud_images/test': {
                             'default': False
                         }})
예제 #32
0
    def test_wait_until_empty(self):
        array_mock = mock.MagicMock(name='unittest')

        responses = (['a', 'b', 'c'],
                     ['a', 'b'],
                     ['a'],
                     [])

        get_func = self.client_mock.get_server_array_current_instances
        get_func.side_effect = [
            tornado_value(r) for r in responses]

        ret = yield self.actor._wait_until_empty(array_mock, sleep=0.01)
        self.assertEqual(get_func.call_count, 4)
        self.assertEqual(ret, None)
예제 #33
0
    def test_remove(self):
        act = elb_actor.DeregisterInstance('UTA', {
            'elb': 'test',
            'region': 'us-east-1',
            'instances': 'test'
        })

        elb = mock.Mock()
        instance = 'i-un173s7'

        act._wait_on_draining = mock.Mock()
        act._wait_on_draining.return_value = helper.tornado_value(mock.Mock())
        yield act._remove(elb, [instance])

        elb.deregister_instances.assert_called_with([instance])
예제 #34
0
    def test_ensure_tags_with_mocked_mci(self):
        mci = mock.MagicMock(name='mci')
        mci.href = None
        self.client_mock.get_resource_tags = mock.MagicMock(name='get')
        self.client_mock.get_resource_tags.side_effect = [
            tornado_value(['tag1', 'tag2'])
        ]

        self.client_mock.add_resource_tags = mock.MagicMock(name='add')
        self.client_mock.add_resource_tags.side_effect = [
            tornado_value(None)
        ]

        self.client_mock.delete_resource_tags = mock.MagicMock(name='delete')
        self.client_mock.delete_resource_tags.side_effect = [
            tornado_value(None)
        ]

        yield self.actor._ensure_tags(mci, 'tag')

        self.client_mock.add_resource_tags.assert_has_calls([
            mock.call(mci, ['tag'])
        ])
        self.assertFalse(self.client_mock.delete_resource_tags.called)
예제 #35
0
 def test_commit(self):
     mci = mock.MagicMock(name='mci')
     fake_mci_setting = mock.MagicMock(name='mci_setting')
     fake_mci_setting.soul = {
         'revision': 2
     }
     self.client_mock.commit_resource.side_effect = [
         helper.tornado_value(fake_mci_setting)
     ]
     self.actor.log = mock.MagicMock(name='log')
     yield self.actor._commit(mci, 'message')
     self.actor.log.assert_has_calls([
         mock.call.info('Committing a new revision'),
         mock.call.info('Committed revision 2')
     ])
예제 #36
0
    def test_create_mci_already_exists(self):
        mci = mock.MagicMock(name='mci')
        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value(mci)
        ]
        ret = yield self.actor._create_mci(
            name='testmci',
            params=[
                ('test', 'test'),
                ('testa', 'testa')
            ]
        )

        self.assertEqual(mci, ret)
        self.assertFalse(self.client_mock.create_resource.called)
예제 #37
0
    def test_ensure_mci_default_invalid_api_data(self):
        self.actor.st.links['default_multi_cloud_image'] = 'junk'

        st_mci_a = mock.MagicMock(name='st_mci_a')
        st_mci_a.links = {
            'self': '/api/server_template_multi_cloud_image/A',
            'multi_cloud_image': '/api/clouds/A/images/abc'
        }
        st_mci_b = mock.MagicMock(name='st_mci_b')
        st_mci_b.links = {
            'self': '/api/server_template_multi_cloud_image/B',
            'multi_cloud_image': 'JUNK DATA'
        }

        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value([st_mci_a, st_mci_b])
        ]

        self.client_mock.make_generic_request.side_effect = [
            helper.tornado_value(None)
        ]

        with self.assertRaises(exceptions.InvalidOptions):
            yield self.actor._ensure_mci_default()
예제 #38
0
    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([])
예제 #39
0
    def test_execute(self):
        actor = pingdom.Unpause('Unit Test Action', {'name': 'lollipop'})

        actor._pingdom_client = mock.Mock()
        actor._get_check = mock_tornado({
            'name': 'lollipop',
            'hostname': 'http://lollipop.com',
            'id': 'lol'
        })
        actor._pingdom_client.check().http_put.return_value = tornado_value()

        yield actor._execute()

        self.assertEquals(actor._get_check._call_count, 1)
        actor._pingdom_client.check.assert_called_with(check_id='lol')
        actor._pingdom_client.check().http_put.assert_called_with(
            paused='false')
예제 #40
0
    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'])
예제 #41
0
    def test_ensure_template_no_diff(self):
        self.actor._create_change_set = mock.MagicMock(name='_create_change')
        self.actor._wait_until_change_set_ready = mock.MagicMock(name='_wait')
        fake_stack = create_fake_stack('fake', 'CREATE_COMPLETE')

        # Grab the raw stack body from the test actor -- this is what it should
        # compare against, so this test should cause the method to bail out and
        # not make any changes.
        template = json.loads(self.actor._template_body)
        get_temp_mock = mock.MagicMock(name='_get_stack_template')
        self.actor._get_stack_template = get_temp_mock
        self.actor._get_stack_template.return_value = tornado_value(template)

        ret = yield self.actor._ensure_template(fake_stack)
        self.assertEquals(None, ret)

        self.assertFalse(self.actor._create_change_set.called)
        self.assertFalse(self.actor._wait_until_change_set_ready.called)
예제 #42
0
    def test_get_bindings(self):
        boot_binding_c = mock.MagicMock()
        boot_binding_c.soul = {'sequence': 'boot', 'position': 0}

        operational_binding_c = mock.MagicMock()
        operational_binding_c.soul = {'sequence': 'operational', 'position': 0}

        existing_bindings = [boot_binding_c, operational_binding_c]

        self.client_mock.show.side_effect = [
            helper.tornado_value(existing_bindings)
        ]

        (boot, operational, decommission) = yield self.actor._get_bindings()

        self.assertEquals([boot_binding_c], boot)
        self.assertEquals([operational_binding_c], operational)
        self.assertEquals([], decommission)
예제 #43
0
    def test_create_stack_wait_until_raises_boto_error(self):
        actor = cloudformation.Create(
            'Unit Test Action', {
                'name': 'unit-test-cf',
                'region': 'us-west-2',
                'template':
                'examples/test/aws.cloudformation/cf.integration.json'
            })
        actor.cf3_conn.create_stack = mock.MagicMock(name='create_stack_mock')
        actor.cf3_conn.create_stack.return_value = {'StackId': 'arn:123'}

        actor._wait_until_state = mock.MagicMock(name='_wait_until_state')
        actor._wait_until_state.side_effect = cloudformation.StackFailed()

        actor._get_stack_events = mock.MagicMock(name='_get_stack_events')
        actor._get_stack_events.return_value = tornado_value(['Log Message'])

        with self.assertRaises(cloudformation.StackFailed):
            yield actor._create_stack(stack='test')
예제 #44
0
    def test_set_state_absent(self):
        # First, lets copy the desired configuration blob. The first test,
        # we'll copy the blob and we'll ensure that they are the same.
        self.actor._group = copy.deepcopy(self.actor._config)

        # Insert some fake data that would normally have been returned in the
        # included blob from Spotinst.
        self.actor._group['group']['id'] = 'sig-1234123'
        self.actor._group['group']['createdAt'] = 'timestamp'
        self.actor._group['group']['updatedAt'] = 'timestamp'

        fake_ret = {'ok': True}
        self.actor._options['state'] = 'absent'
        mock_client = mock.MagicMock()
        mock_client.http_delete.return_value = tornado_value(fake_ret)
        self.actor._client.aws.ec2.delete_group.return_value = mock_client

        yield self.actor._set_state()
        mock_client.http_delete.assert_called_with()
예제 #45
0
    def test_get_mci_mappings(self):
        mci_map = mock.MagicMock(name='mci_mapping')
        mci_map.soul = {'is_default': True}
        mci_map.links = {'multi_cloud_image': '/api/mci/test'}
        mci_map.href = '/api/st_mci/test'

        self.client_mock.find_by_name_and_keys.side_effect = [
            helper.tornado_value(mci_map)
        ]

        ret = yield self.actor._get_mci_mappings()

        self.maxDiff = None
        self.assertEqual(
            ret, {
                '/api/mci/test': {
                    'default': True,
                    'map_href': '/api/st_mci/test',
                    'map_obj': mci_map
                }
            })
예제 #46
0
 def test_create_stack_file_with_role(self):
     stack = 'examples/test/aws.cloudformation/cf.integration.json'
     actor = cloudformation.Create(
         'Unit Test Action',
         {'name': 'unit-test-cf',
          'region': 'us-west-2',
          'role_arn': 'test_role_arn',
          'template': stack})
     actor._wait_until_state = mock.MagicMock(name='_wait_until_state')
     actor._wait_until_state.side_effect = [tornado_value(None)]
     actor.cf3_conn.create_stack = mock.MagicMock(name='create_stack_mock')
     actor.cf3_conn.create_stack.return_value = {'StackId': 'arn:123'}
     ret = yield actor._create_stack(stack='test')
     self.assertEquals(ret, 'arn:123')
     actor.cf3_conn.create_stack.assert_called_with(
         TemplateBody=mock.ANY,
         EnableTerminationProtection=False,
         Parameters=[],
         RoleARN=u'test_role_arn',
         TimeoutInMinutes=60,
         Capabilities=[],
         StackName='test',
         OnFailure='DELETE')
예제 #47
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)

        # 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
        yield self.actor._execute()
        call_arg_str = str(mock_create_res.call_args_list)
        for arg in [
                'alert_spec[escalation_name]', 'alert_spec[threshold]',
                'alert_spec[variable]', 'alert_spec[subject_href]',
                'alert_spec[description]', 'alert_spec[file]',
                'alert_spec[duration]', 'alert_spec[condition]',
                'alert_spec[name]'
        ]:
            self.assertIn(arg, call_arg_str)
예제 #48
0
 def test_execute(self):
     self.actor._validate_template = mock.MagicMock()
     self.actor._validate_template.return_value = tornado_value(None)
     self.actor._ensure_stack = mock.MagicMock()
     self.actor._ensure_stack.return_value = tornado_value(None)
     yield self.actor._execute()
예제 #49
0
 def test_get_mci_returns_empty_list(self):
     self.client_mock.find_by_name_and_keys.side_effect = [
         helper.tornado_value([])
     ]
     ret = yield self.actor._get_mci('testmci')
     self.assertEquals(None, ret)
예제 #50
0
 def test_update_stack_ensure_template(self):
     fake_stack = create_fake_stack('fake', 'CREATE_COMPLETE')
     self.actor._ensure_template = mock.MagicMock(name='_ensure_stack')
     self.actor._ensure_template.return_value = tornado_value(None)
     yield self.actor._update_stack(fake_stack)
     self.actor._ensure_template.assert_called_with(fake_stack)
예제 #51
0
 def test_set_packages(self):
     self.actor._update_params = mock.MagicMock()
     self.actor._update_params.side_effect = [
         helper.tornado_value(None)]
     yield self.actor._set_packages()
     self.assertTrue(self.actor._update_params.called)
예제 #52
0
 def test_compare_alerts(self):
     self.actor.alert_specs = mock.MagicMock()
     self.actor.alert_specs._compare_specs.side_effect = [
         helper.tornado_value(False)]
     ret = yield self.actor._compare_alerts()
     self.assertEquals(False, ret)
예제 #53
0
    def test_roll_group(self):
        # First, lets copy the desired configuration blob. The first test,
        # we'll copy the blob and we'll ensure that they are the same.
        self.actor._group = copy.deepcopy(self.actor._config)

        # Insert some fake data that would normally have been returned in the
        # included blob from Spotinst.
        self.actor._group['group']['id'] = 'sig-1234123'
        self.actor._group['group']['createdAt'] = 'timestamp'
        self.actor._group['group']['updatedAt'] = 'timestamp'

        # Mock out the returned calls from Spotinst. The first time we call the
        # roll status method, we'll return no rolls in progress. The second
        # time, there will be a single roll in progress (pretending that the
        # roll_group call was successful), and then the third time it will
        # return no rolls in progress again (pretending that we're done).
        in_progress = {
            "id": "sbgd-44e6d801",
            "status": "in_progress",
            "progress": {
                "unit": "percent",
                "value": 0
            },
            "createdAt": "2017-01-05T15:48:28.000+0000",
            "updatedAt": "2017-01-05T15:49:15.000+0000"
        }
        finished = {
            "id": "sbgd-9f1aa4f6",
            "status": "finished",
            "progress": {
                "unit": "percent",
                "value": 100
            },
            "createdAt": "2017-01-05T15:06:25.000+0000",
            "updatedAt": "2017-01-05T15:22:17.000+0000"
        }

        roll_responses = [
            # First response, no rolls are in progress
            tornado_value({
                "request": {
                    "id": "request-1-no-in-progress",
                    "url": "/aws/ec2/group/sig-b55014f1/roll?limit=5",
                    "method": "GET",
                    "timestamp": "2017-01-05T15:50:44.215Z"
                },
                "response": {
                    "status": {
                        "code": 200,
                        "message": "OK"
                    },
                    "kind": "spotinst:aws:ec2:group:roll",
                    "items": [finished]
                }
            }),

            # Ok now pretend that one roll is in progress, and one is finished
            tornado_value({
                "request": {
                    "id": "request-2-one-in-progress",
                    "url": "/aws/ec2/group/sig-b55014f1/roll?limit=5",
                    "method": "GET",
                    "timestamp": "2017-01-05T15:50:44.215Z"
                },
                "response": {
                    "status": {
                        "code": 200,
                        "message": "OK"
                    },
                    "kind": "spotinst:aws:ec2:group:roll",
                    "items": [in_progress, finished]
                }
            }),

            # Finally, no rolls in progress.
            tornado_value({
                "request": {
                    "id": "request-3-none-in-progress",
                    "url": "/aws/ec2/group/sig-b55014f1/roll?limit=5",
                    "method": "GET",
                    "timestamp": "2017-01-05T15:50:44.215Z"
                },
                "response": {
                    "status": {
                        "code": 200,
                        "message": "OK"
                    },
                    "kind": "spotinst:aws:ec2:group:roll",
                    "items": [finished, finished]
                }
            })
        ]

        # Generate a basic mock object for the entire 'roll' RestConsumer. Mock
        # out the http_get() method to return back the three fake responses
        # above. Mock out the http_put() method to just return safely.
        roll_mock = mock.MagicMock()
        roll_mock.http_get.side_effect = roll_responses
        roll_mock.http_put.side_effect = [tornado_value(None)]
        self.actor._client.aws.ec2.roll.return_value = roll_mock

        # Make the call, and make sure we wait for all roll operations to
        # finish
        self.actor._options['wait_on_roll'] = True
        yield self.actor._roll_group(delay=0.01)

        # Now verify that all the calls were made to the roll_mock
        roll_mock.assert_has_calls([
            mock.call.http_get(),
            mock.call.http_put(gracePeriod=600, batchSizePercentage=20),
            mock.call.http_get(),
            mock.call.http_get(),
        ])
예제 #54
0
 def test_set_state_absent(self):
     self.actor._delete_spec = mock.MagicMock()
     self.actor._delete_spec.side_effect = [helper.tornado_value(None)]
     self.actor._options['state'] = 'absent'
     yield self.actor._set_state()
     self.assertTrue(self.actor._delete_spec.called)
예제 #55
0
 def test_set_spec(self):
     self.actor._update_spec = mock.MagicMock()
     self.actor._update_spec.side_effect = [helper.tornado_value(None)]
     yield self.actor._set_spec()
     self.assertTrue(self.actor._update_spec.called)
예제 #56
0
 def test_get_specs(self):
     self.actor.alert_actors[0]._get_spec.side_effect = [
         helper.tornado_value(1)
     ]
     ret = yield self.actor._get_specs()
     self.assertEquals([1], ret)
예제 #57
0
 def __init__(self, *args, **kwargs):
     super(FakeActor, self).__init__(*args, **kwargs)
     self.conn = mock.MagicMock()
     self.conn.call.return_value = helper.tornado_value(None)
     self.conn.call.__name__ = 'test_call'
예제 #58
0
 def test_get_mci_returns_too_many_things(self):
     self.client_mock.find_by_name_and_keys.side_effect = [
         helper.tornado_value([1, 2])
     ]
     with self.assertRaises(exceptions.RecoverableActorFailure):
         yield self.actor._get_mci('testmci')
예제 #59
0
    def test_ensure_settings(self):
        mci = mock.MagicMock(name='mci')
        mci.soul = {
            'name': 'testmci',
            'description': 'test mci desc different'
        }

        # For simplicity (and to ensure we're passing the right data into the
        # create/delete/update mci setting methods), we mock out the final API
        # call.. not the internal actor methods.
        self.client_mock.create_resource.side_effect = [
            helper.tornado_value(None)
        ]
        self.client_mock.update.side_effect = [helper.tornado_value(None)]
        self.client_mock.destroy_resource.side_effect = [
            helper.tornado_value(None)
        ]

        # mci_setting_a looks like the desired clouda settings, but has the
        # wrong image id, so it will trigger an update_mci_setting() call
        mci_setting_a = mock.MagicMock(name='mci_setting_a')
        mci_setting_a.links = {
            'cloud': '/api/clouds/A',
            'image': '/api/clouds/A/images/bad_image_id',
            'instance_type': '/api/clouds/A/instance_types/abc'
        }

        # mci_setting_b is deliberately missing, which will trigger a
        # create_mci_setting() call

        # mci_setting_c doesn't exist at all  in our desired settings, so it
        # should trigger a delete_mci_setting() call
        mci_setting_c = mock.MagicMock(name='mci_setting_c')
        mci_setting_c.links = {
            'cloud': '/api/clouds/C',
            'image': '/api/clouds/C/images/abc',
            'instance_type': '/api/clouds/C/instance_types/abc'
        }

        self.client_mock.show.side_effect = [
            # The first call of _client.show should return the list of settings
            # objects we've created above.
            helper.tornado_value([
                mci_setting_a,
                mci_setting_c,
            ])
        ]

        # Mock out _get_mci_setting_def and have it return the clouda/cloudb
        # href populated setting lists.
        self.actor._get_mci_setting_def = mock.MagicMock(name='get_mci_set')
        self.actor._get_mci_setting_def.side_effect = [
            helper.tornado_value(self.clouda_href_tuples),
            helper.tornado_value(self.cloudb_href_tuples),
        ]

        # Go for it
        yield self.actor._ensure_settings(mci)

        # Finally, make sure that the right things were deleted/updated/etc
        self.client_mock.create_resource.assert_has_calls([
            mock.call(mci.settings, self.cloudb_href_tuples),
        ])
        self.client_mock.update.assert_has_calls([
            mock.call(mci_setting_a, self.clouda_href_tuples),
        ])
        self.client_mock.destroy_resource.assert_has_calls(
            [mock.call(mci_setting_c)])
예제 #60
0
 def test_add_resource_tags(self):
     resource = mock.MagicMock(name='resource')
     self.client_mock.add_resource_tags.side_effect = [tornado_value(None)]
     yield self.actor._add_resource_tags(resource=resource, tags=['a', 'b'])
     self.client_mock.add_resource_tags.assert_has_calls(
         [mock.call(resource, ['a', 'b'])])