def test_execute_plan_when_outline_not_specified(self):
context = self._get_context()
build_action = build.Action(context)
with mock.patch.object(build_action, "_generate_plan") as \
mock_generate_plan:
build_action.run(outline=False)
self.assertEqual(mock_generate_plan().execute.call_count, 1)
def setUp(self):
self.context = self._get_context()
self.provider = Provider(None, interactive=False,
recreate_failed=False)
self.build_action = build.Action(self.context, provider=self.provider)
self.stack = mock.MagicMock()
self.stack.name = 'vpc'
self.stack.fqn = 'vpc'
self.stack.locked = False
self.stack_status = None
plan = self.build_action._generate_plan()
_, self.step = plan.list_pending()[0]
self.step.stack = self.stack
def patch_object(*args, **kwargs):
m = mock.patch.object(*args, **kwargs)
self.addCleanup(m.stop)
m.start()
def get_stack(name, *args, **kwargs):
if name != self.stack.name or not self.stack_status:
raise StackDoesNotExist(name)
return {'StackName': self.stack.name,
'StackStatus': self.stack_status,
'Tags': []}
patch_object(self.provider, 'get_stack', side_effect=get_stack)
patch_object(self.provider, 'update_stack')
patch_object(self.provider, 'create_stack')
patch_object(self.provider, 'destroy_stack')
patch_object(self.build_action, "s3_stack_push")
def test_dont_execute_plan_when_outline_specified(self):
context = self._get_context()
build_action = build.Action(context, cancel=MockThreadingEvent())
with mock.patch.object(build_action, "_generate_plan") as \
mock_generate_plan:
build_action.run(outline=True)
self.assertEqual(mock_generate_plan().execute.call_count, 0)
def test_launch_stack_step_statuses(self):
mock_provider = mock.MagicMock()
mock_stack = mock.MagicMock()
context = self._get_context()
build_action = build.Action(context, provider=mock_provider)
plan = build_action._generate_plan()
_, step = plan.list_pending()[0]
step.stack = mock.MagicMock()
step.stack.locked = False
# mock provider shouldn't return a stack at first since it hasn't been
# launched
mock_provider.get_stack.return_value = None
with mock.patch.object(build_action, "s3_stack_push"):
# initial status should be PENDING
self.assertEqual(step.status, PENDING)
# initial run should return SUBMITTED since we've passed off to CF
status = step.run()
step.set_status(status)
self.assertEqual(status, SUBMITTED)
self.assertEqual(status.reason, "creating new stack")
# provider should now return the CF stack since it exists
mock_provider.get_stack.return_value = mock_stack
# simulate that we're still in progress
mock_provider.is_stack_in_progress.return_value = True
mock_provider.is_stack_completed.return_value = False
status = step.run()
step.set_status(status)
# status should still be SUBMITTED since we're waiting for it to
# complete
self.assertEqual(status, SUBMITTED)
self.assertEqual(status.reason, "creating new stack")
# simulate completed stack
mock_provider.is_stack_completed.return_value = True
mock_provider.is_stack_in_progress.return_value = False
status = step.run()
step.set_status(status)
self.assertEqual(status, COMPLETE)
self.assertEqual(status.reason, "creating new stack")
# simulate stack should be skipped
mock_provider.is_stack_completed.return_value = False
mock_provider.is_stack_in_progress.return_value = False
mock_provider.update_stack.side_effect = StackDidNotChange
status = step.run()
step.set_status(status)
self.assertEqual(status, SKIPPED)
self.assertEqual(status.reason, "nochange")
# simulate an update is required
mock_provider.reset_mock()
mock_provider.update_stack.side_effect = None
step.set_status(PENDING)
status = step.run()
step.set_status(status)
self.assertEqual(status, SUBMITTED)
self.assertEqual(status.reason, "updating existing stack")
self.assertEqual(mock_provider.update_stack.call_count, 1)
def test_generate_plan(self):
context = self._get_context()
build_action = build.Action(context)
plan = build_action._generate_plan()
self.assertEqual(
plan.keys(),
[context.get_fqn(s) for s in ["other", "vpc", "bastion", "db"]],
)
def test_generate_plan(self):
context = self._get_context()
build_action = build.Action(context)
plan = build_action._generate_plan()
self.assertEqual(
plan.keys(),
[context.get_fqn(s) for s in ['other', 'vpc', 'bastion', 'db']],
)
def test_get_stack_execution_order(self):
context = self._get_context()
build_action = build.Action(context)
dependencies = build_action._get_dependencies()
execution_order = build_action.get_stack_execution_order(dependencies)
self.assertEqual(
execution_order,
[context.get_fqn(s) for s in ["other", "vpc", "bastion", "db"]],
)
def test_get_stack_execution_order(self):
context = self._get_context()
build_action = build.Action(context)
dependencies = build_action._get_dependencies()
execution_order = build_action.get_stack_execution_order(dependencies)
self.assertEqual(
execution_order,
[context.get_fqn(s) for s in ['other', 'vpc', 'bastion', 'db']],
)
def test_generate_plan(self):
context = self._get_context()
build_action = build.Action(context, cancel=MockThreadingEvent())
plan = build_action._generate_plan()
self.assertEqual(
{
'db': set(['bastion', 'vpc']),
'bastion': set(['vpc']),
'other': set([]),
'vpc': set([])
}, plan.graph.to_dict())
def test_generate_plan(self):
context = self._get_context()
build_action = build.Action(context)
plan = build_action._generate_plan()
self.assertEqual(
{
'namespace-db': set(['namespace-bastion', 'namespace-vpc']),
'namespace-bastion': set(['namespace-vpc']),
'namespace-other': set([]),
'namespace-vpc': set([])
}, plan.graph.to_dict())
def setUp(self):
self.context = self._get_context()
self.session = get_session(region=None)
self.provider = Provider(self.session,
interactive=False,
recreate_failed=False)
provider_builder = MockProviderBuilder(self.provider)
self.build_action = build.Action(self.context,
provider_builder=provider_builder,
cancel=MockThreadingEvent())
self.stack = mock.MagicMock()
self.stack.region = None
self.stack.name = 'vpc'
self.stack.fqn = 'vpc'
self.stack.blueprint.rendered = '{}'
self.stack.locked = False
self.stack_status = None
plan = self.build_action._generate_plan()
self.step = plan.steps[0]
self.step.stack = self.stack
def patch_object(*args, **kwargs):
m = mock.patch.object(*args, **kwargs)
self.addCleanup(m.stop)
m.start()
def get_stack(name, *args, **kwargs):
if name != self.stack.name or not self.stack_status:
raise StackDoesNotExist(name)
return {
'StackName': self.stack.name,
'StackStatus': self.stack_status,
'Outputs': [],
'Tags': []
}
def get_events(name, *args, **kwargs):
return [{
'ResourceStatus': 'ROLLBACK_IN_PROGRESS',
'ResourceStatusReason': 'CFN fail'
}]
patch_object(self.provider, 'get_stack', side_effect=get_stack)
patch_object(self.provider, 'update_stack')
patch_object(self.provider, 'create_stack')
patch_object(self.provider, 'destroy_stack')
patch_object(self.provider, 'get_events', side_effect=get_events)
patch_object(self.build_action, "s3_stack_push")
def test_get_dependencies(self):
context = self._get_context()
build_action = build.Action(context)
dependencies = build_action._get_dependencies()
self.assertEqual(
dependencies[context.get_fqn("bastion")],
set([context.get_fqn("vpc")]),
)
self.assertEqual(
dependencies[context.get_fqn("db")],
set([context.get_fqn(s) for s in ["vpc", "bastion"]]),
)
self.assertFalse(dependencies[context.get_fqn("other")])
def test_get_dependencies(self):
context = self._get_context()
build_action = build.Action(context)
dependencies = build_action._get_dependencies()
self.assertEqual(
dependencies[context.get_fqn('bastion')],
set([context.get_fqn('vpc')]),
)
self.assertEqual(
dependencies[context.get_fqn('db')],
set([context.get_fqn(s) for s in ['vpc', 'bastion']]),
)
self.assertFalse(dependencies[context.get_fqn('other')])
def test_Raises_StackDoesNotExist_from_lookup_non_included_stack(self):
# This test is testing the specific scenario listed in PR 466
# Because the issue only threw a KeyError when a stack was missing
# in the `--stacks` flag at runtime of a `stacker build` run
# but needed for an output lookup in the stack specified
mock_provider = mock.MagicMock()
context = Context(config=Config({
"namespace": "namespace",
"stacks": [
{"name": "bastion",
"variables": {"test": "${output vpc::something}"}
}]
}))
build_action = build.Action(context, provider=mock_provider)
with self.assertRaises(StackDoesNotExist):
build_action._generate_plan()
def setUp(self):
self.context = self._get_context()
self.session = get_session(region=None)
self.provider = self._make_provider()
provider_builder = MockProviderBuilder(self.provider)
self.build_action = build.Action(self.context,
provider_builder=provider_builder,
cancel=MockThreadingEvent())
self._patch_object(self.build_action, "s3_stack_push")
self.stack = TestStack("vpc", self.context)
self.stack_status = None
plan = self.build_action._generate_plan()
self.step = plan.steps[0]
self.step.stack = self.stack
def setUp(self):
self.context = Context(config=Config({"namespace": "namespace"}))
self.provider = TestProvider()
self.build_action = build.Action(self.context,
provider_builder=MockProviderBuilder(
self.provider))
def setUp(self):
self.context = Context({"namespace": "namespace"})
self.build_action = build.Action(self.context, provider=TestProvider())
response = ec2.describe_subnets(
Filters=[
{
'Name': 'vpc-id',
'Values': [
vpc_id
]
}
]
)
subnet_ids = [x['SubnetId'] for x in response['Subnets']]
provider_builder = ProviderBuilder(region="ap-southeast-2", recreate_failed=True, interactive=False)
context = construct_context(subnet_ids[0])
action = build.Action(context, provider_builder=provider_builder)
action.run(tail=True)
cloudformation = boto3.client("cloudformation")
asg_name = cloudformation.describe_stack_resources(
StackName="ebs-pin-test",
LogicalResourceId="AutoScalingGroup"
)['StackResources'][0]['PhysicalResourceId']
logging.info("asg_name: {}".format(asg_name))
autoscaling = boto3.client('autoscaling')
count = return_count_after_update(asg_name, subnet_ids[0], autoscaling=autoscaling, ec2=ec2)
assert count >= 1
previous_count = count
context = construct_context(subnet_ids[1])
