stack_master 1.5.0 → 1.6.0

data/spec/stack_master/stack_differ_spec.rb

@@ -1,46 +0,0 @@
-RSpec.describe StackMaster::StackDiffer do
-  subject(:differ) { described_class.new(proposed_stack, stack) }
-  let(:current_params) { Hash.new }
-  let(:proposed_params) { { 'param1' => 'hello'} }
-  let(:stack) { StackMaster::Stack.new(stack_name: stack_name,
-                                       region: region,
-                                       stack_id: 123,
-                                       template_body: '{}',
-                                       template_format: :json,
-                                       parameters: current_params) }
-  let(:proposed_stack) { StackMaster::Stack.new(stack_name: stack_name,
-                                                region: region,
-                                                parameters: proposed_params,
-                                                template_body: "{\"a\": 1}",
-                                                template_format: :json) }
-  let(:stack_name) { 'myapp-vpc' }
-  let(:region) { 'us-east-1' }
-
-  describe "#proposed_parameters" do
-    let(:current_params) { { 'param1' => 'hello',
-                             'param2' => '****'} }
-    it "stars out noecho params" do
-      expect(differ.proposed_parameters).to eq "---\nparam1: hello\nparam2: \"****\"\n"
-    end
-  end
-
-  describe "#output_diff" do
-    context "entirely new stack" do
-      let(:stack) { nil }
-
-      it "outputs the entire stack" do
-        expect { differ.output_diff }.to output(/\+  \"a\"\: 1/).to_stdout
-        expect { differ.output_diff }.to output(/param1\: hello/).to_stdout
-        expect { differ.output_diff }.to output(/No stack found/).to_stdout
-      end
-    end
-
-    context "stack update" do
-      it "outputs the stack diff" do
-        expect { differ.output_diff }.to output(/\+  \"a\"\: 1/).to_stdout
-        expect { differ.output_diff }.to output(/param1\: hello/).to_stdout
-        expect { differ.output_diff }.to_not output(/No stack found/).to_stdout
-      end
-    end
-  end
-end

data/spec/stack_master/stack_events/fetcher_spec.rb

@@ -1,40 +0,0 @@
-RSpec.describe StackMaster::StackEvents::Fetcher do
-  let(:cf) { Aws::CloudFormation::Client.new }
-  let(:stack_name) { 'blah' }
-
-  before do
-    allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf)
-    allow(StackMaster::StackEvents::Streamer).to receive(:stream)
-    allow(StackMaster::PagedResponseAccumulator).to receive(:call).with(StackMaster.cloud_formation_driver, :describe_stack_events, { stack_name: stack_name }, :stack_events).and_return(OpenStruct.new(stack_events: events))
-  end
-
-  context 'with 2 stack events' do
-    let(:events) { [
-      OpenStruct.new(event_id: '1', stack_id: '1', stack_name: 'blah', timestamp: Time.now),
-      OpenStruct.new(event_id: '2', stack_id: '1', stack_name: 'blah', timestamp: Time.now)
-    ] }
-
-    it 'returns stack events' do
-      events = StackMaster::StackEvents::Fetcher.fetch(stack_name, 'us-east-1')
-      expect(events.count).to eq 2
-    end
-  end
-
-  context 'filtering with a from timestamp' do
-    let(:two_pm) { Time.parse('2015-10-27 14:00') }
-    let(:three_pm) { Time.parse('2015-10-27 15:00') }
-    let(:four_pm) { Time.parse('2015-10-27 16:00') }
-
-    let(:events) {
-      [
-        OpenStruct.new(event_id: '1', stack_id: '1', stack_name: 'blah', timestamp: two_pm),
-        OpenStruct.new(event_id: '2', stack_id: '1', stack_name: 'blah', timestamp: four_pm),
-      ]
-    }
-
-    it 'only returns events after the timestamp' do
-      events = StackMaster::StackEvents::Fetcher.fetch(stack_name, 'us-east-1', from: three_pm)
-      expect(events.map(&:event_id)).to eq ['2']
-    end
-  end
-end

data/spec/stack_master/stack_events/presenter_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe StackMaster::StackEvents::Presenter do
-  describe "#print_event" do
-    let(:time) { Time.new(2001,1,1,2,2,2) }
-    let(:event) do
-      double(:event,
-             timestamp:              time,
-             logical_resource_id:    'MyAwesomeQueue',
-             resource_type:          'AWS::SQS::Queue',
-             resource_status:        'CREATE_IN_PROGRESS',
-             resource_status_reason: 'Resource creation Initiated')
-    end
-    subject(:print_event) { described_class.print_event($stdout, event) }
-
-    it "nicely presents event data" do
-      expect { print_event }.to output("\e[0;33;49m2001-01-01 02:02:02 #{time.strftime('%z')} MyAwesomeQueue AWS::SQS::Queue CREATE_IN_PROGRESS Resource creation Initiated\e[0m\n").to_stdout
-    end
-  end
-end

data/spec/stack_master/stack_events/streamer_spec.rb

@@ -1,47 +0,0 @@
-RSpec.describe StackMaster::StackEvents::Streamer do
-  let(:events_first_call) { [
-    OpenStruct.new(event_id: '1', resource_status: 'BLAH', timestamp: Time.now),
-    OpenStruct.new(event_id: '2', resource_status: 'BLAH', timestamp: Time.now),
-    OpenStruct.new(event_id: '3', resource_status: 'BLAH', timestamp: Time.now),
-  ] }
-  let(:events_second_call) {
-    events_first_call + [
-      OpenStruct.new(event_id: '4', resource_status: 'UPDATE_COMPLETE', resource_type: 'AWS::CloudFormation::Stack', logical_resource_id: stack_name, timestamp: Time.now)
-    ]
-  }
-  let(:stack_name) { 'stack-name' }
-  let(:region) { 'us-east-1' }
-  let(:now) { Time.now }
-
-  before do
-    allow(StackMaster::StackEvents::Fetcher).to receive(:fetch).with(stack_name, region, from: now).and_return(events_first_call, events_second_call)
-    allow(Time).to receive(:now).and_return(now)
-  end
-
-  it 'returns after seeing a finish state' do
-    events = []
-    StackMaster::StackEvents::Streamer.stream(stack_name, region, sleep_between_fetches: 0) do |event|
-      events << event
-    end
-  end
-
-  it 'streams events to an io object' do
-    io = StringIO.new
-    StackMaster::StackEvents::Streamer.stream(stack_name, region, sleep_between_fetches: 0, io: io)
-    expect(io.string).to include('UPDATE_COMPLETE')
-  end
-
-  context "the stack is in a failed state" do
-    let(:events_second_call) {
-      events_first_call + [
-        OpenStruct.new(event_id: '4', resource_status: 'ROLLBACK_FAILED', resource_type: 'AWS::CloudFormation::Stack', logical_resource_id: stack_name, timestamp: Time.now)
-      ]
-    }
-
-    it 'raises an error on failure' do
-      expect {
-        StackMaster::StackEvents::Streamer.stream(stack_name, region, sleep_between_fetches: 0)
-      }.to raise_error(StackMaster::StackEvents::Streamer::StackFailed)
-    end
-  end
-end

data/spec/stack_master/stack_spec.rb

@@ -1,184 +0,0 @@
-RSpec.describe StackMaster::Stack do
-  let(:region) { 'us-east-1' }
-  let(:stack_name) { 'myapp_vpc' }
-  let(:stack_id) { '1' }
-  let(:stack_policy_body) { '{}' }
-  let(:cf) { Aws::CloudFormation::Client.new }
-  subject(:stack) { StackMaster::Stack.find(region, stack_name) }
-
-  before do
-    allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf)
-  end
-
-  describe '.find' do
-    context 'when the stack exists in AWS' do
-      let(:parameters) {
-        [
-            {parameter_key: 'param1', parameter_value: 'value1'},
-            {parameter_key: 'param2', parameter_value: 'value2'}
-        ]
-      }
-      before do
-        cf.stub_responses(:describe_stacks, stacks: [{stack_id: stack_id, stack_name: stack_name, creation_time: Time.now, stack_status: 'UPDATE_COMPLETE', parameters: parameters, notification_arns: ['test_arn'], role_arn: 'test_service_role_arn'}])
-        cf.stub_responses(:get_template, template_body: "{}")
-        cf.stub_responses(:get_stack_policy, stack_policy_body: stack_policy_body)
-      end
-
-      it 'returns a stack object with a stack_id' do
-        expect(stack.stack_id).to eq stack_id
-      end
-
-      it "returns a template body" do
-        expect(stack.template_body).to eq "{}"
-      end
-
-      it 'parses parameters into a hash' do
-        expect(stack.parameters).to eq({'param1' => 'value1', 'param2' => 'value2'})
-      end
-
-      it 'sets role_arn' do
-        expect(stack.role_arn).to eq('test_service_role_arn')
-      end
-
-      it 'sets notification_arns' do
-        expect(stack.notification_arns).to eq(['test_arn'])
-      end
-
-      it 'sets the stack policy' do
-        expect(stack.stack_policy_body).to eq stack_policy_body
-      end
-    end
-
-    context 'when the stack does not exist in AWS' do
-      before do
-        cf.stub_responses(:describe_stacks, Aws::CloudFormation::Errors::ValidationError.new('a', 'b'))
-      end
-
-      it 'returns nil' do
-        stack = StackMaster::Stack.find(region, stack_name)
-        expect(stack).to be_nil
-      end
-    end
-
-    context 'when CF returns no stacks' do
-      before do
-        cf.stub_responses(:describe_stacks, stacks: [])
-      end
-
-      it 'returns nil' do
-        stack = StackMaster::Stack.find(region, stack_name)
-        expect(stack).to be_nil
-      end
-    end
-  end
-
-  describe '.generate' do
-    let(:tags) { {'tag1' => 'value1'} }
-    let(:stack_definition) { StackMaster::StackDefinition.new(region: region, stack_name: stack_name, tags: tags, base_dir: '/base_dir', template: template_file_name, notification_arns: ['test_arn'], role_arn: 'test_service_role_arn', stack_policy_file: 'no_replace_rds.json') }
-    let(:config) { StackMaster::Config.new({'stacks' => {}}, '/base_dir') }
-    subject(:stack) { StackMaster::Stack.generate(stack_definition, config) }
-    let(:parameter_hash) { {template_parameters: {'DbPassword' => {'secret' => 'db_password'}}, compile_time_parameters: {}} }
-    let(:resolved_template_parameters) { {'DbPassword' => 'sdfgjkdhlfjkghdflkjghdflkjg', 'InstanceType' => 't2.medium'} }
-    let(:resolved_compile_time_parameters) { {} }
-    let(:template_file_name) { 'template.rb' }
-    let(:template_body) { '{"Parameters": { "VpcId": { "Description": "VPC ID" }, "InstanceType": { "Description": "Instance Type", "Default": "t2.micro" }} }' }
-    let(:template_format) { :json }
-    let(:stack_policy_body) { '{}' }
-
-    before do
-      allow(StackMaster::ParameterLoader).to receive(:load).and_return(parameter_hash)
-      allow(StackMaster::ParameterResolver).to receive(:resolve).with(config,stack_definition,parameter_hash[:template_parameters]).and_return(resolved_template_parameters)
-      allow(StackMaster::ParameterResolver).to receive(:resolve).with(config,stack_definition,parameter_hash[:compile_time_parameters]).and_return(resolved_compile_time_parameters)
-      allow(StackMaster::TemplateCompiler).to receive(:compile).with(config, stack_definition.template_file_path, resolved_compile_time_parameters, stack_definition.compiler_options).and_return(template_body)
-      allow(File).to receive(:read).with(stack_definition.stack_policy_file_path).and_return(stack_policy_body)
-    end
-
-    it 'has the stack definitions region' do
-      expect(stack.region).to eq region
-    end
-
-    it 'has the stack definitions name' do
-      expect(stack.stack_name).to eq stack_name
-    end
-
-    it 'has the stack definitions tags' do
-      expect(stack.tags).to eq tags
-    end
-
-    it 'resolves the parameters' do
-      expect(stack.parameters).to eq resolved_template_parameters
-    end
-
-    it 'compiles the template body' do
-      expect(stack.template_body).to eq template_body
-    end
-
-    it 'has role_arn' do
-      expect(stack.role_arn).to eq 'test_service_role_arn'
-    end
-
-    it 'has notification_arns' do
-      expect(stack.notification_arns).to eq ['test_arn']
-    end
-
-    it 'has the stack policy' do
-      expect(stack.stack_policy_body).to eq stack_policy_body
-    end
-
-    it 'extracts default template parameters' do
-      expect(stack.template_default_parameters).to eq('VpcId' => nil, 'InstanceType' => 't2.micro')
-    end
-
-    it 'exposes parameters with defaults taken into account' do
-      expect(stack.parameters_with_defaults).to eq('DbPassword' => 'sdfgjkdhlfjkghdflkjghdflkjg', 'InstanceType' => 't2.medium', 'VpcId' => nil)
-    end
-  end
-
-  describe '#too_big?' do
-    let(:big_stack) { described_class.new(template_body: "{\"a\":\"#{'x' * 500000}\"}") }
-    let(:medium_stack) { described_class.new(template_body: "{\"a\":\"#{'x' * 60000}\"}") }
-    let(:little_stack) { described_class.new(template_body: "{\"a\":\"#{'x' * 1000}\"}") }
-
-    context 'when not using S3' do
-      it 'returns true for big stacks' do
-        expect(big_stack.too_big?).to be_truthy
-      end
-      it 'returns true for medium stacks' do
-        expect(medium_stack.too_big?).to be_truthy
-      end
-      it 'returns false for small stacks' do
-        expect(little_stack.too_big?).to be_falsey
-      end
-    end
-
-    context 'when using S3' do
-      it 'returns true for big stacks' do
-        expect(big_stack.too_big?(true)).to be_truthy
-      end
-      it 'returns false for medium stacks' do
-        expect(medium_stack.too_big?(true)).to be_falsey
-      end
-      it 'returns false for small stacks' do
-        expect(little_stack.too_big?(true)).to be_falsey
-      end
-    end
-  end
-
-  describe '#missing_parameters?' do
-    subject { stack.missing_parameters? }
-
-    let(:stack) { StackMaster::Stack.new(parameters: parameters, template_body: '{}', template_format: :json) }
-
-    context 'when a parameter has a nil value' do
-      let(:parameters) { {'my_param' => nil} }
-
-      it { should eq true }
-    end
-
-    context 'when no parameers have a nil value' do
-      let(:parameters) { {'my_param' => '1'} }
-
-      it { should eq false }
-    end
-  end
-end

data/spec/stack_master/template_compiler_spec.rb

@@ -1,39 +0,0 @@
-RSpec.describe StackMaster::TemplateCompiler do
-  describe '.compile' do
-    let(:config) { double(template_compilers: { fab: :test_template_compiler }) }
-    let(:template_file_path) { '/base_dir/templates/template.fab' }
-    let(:compile_time_parameters) { { 'InstanceType' => 't2.medium' } }
-
-    class TestTemplateCompiler
-      def self.require_dependencies; end
-      def self.compile(template_file_path, compile_time_parameters, compile_options); end
-    end
-
-    context 'when a template compiler is registered for the given file type' do
-      before {
-        StackMaster::TemplateCompiler.register(:test_template_compiler, TestTemplateCompiler)
-      }
-
-      it 'compiles the template using the relevant template compiler' do
-        expect(TestTemplateCompiler).to receive(:compile).with(template_file_path, compile_time_parameters, anything)
-        StackMaster::TemplateCompiler.compile(config, template_file_path, compile_time_parameters, compile_time_parameters)
-      end
-
-      it 'passes compile_options to the template compiler' do
-        opts = {foo: 1, bar: true, baz: "meh"}
-        expect(TestTemplateCompiler).to receive(:compile).with(template_file_path, compile_time_parameters, opts)
-        StackMaster::TemplateCompiler.compile(config, template_file_path, compile_time_parameters,opts)
-      end
-
-      context 'when template compilation fails' do
-        before { allow(TestTemplateCompiler).to receive(:compile).and_raise(RuntimeError) }
-
-        it 'raise TemplateCompilationFailed exception' do
-          expect{ StackMaster::TemplateCompiler.compile(config, template_file_path, compile_time_parameters, compile_time_parameters)
-          }.to raise_error(
-                 StackMaster::TemplateCompiler::TemplateCompilationFailed,"Failed to compile #{template_file_path}.")
-        end
-      end
-    end
-  end
-end

data/spec/stack_master/template_compilers/cfndsl_spec.rb

@@ -1,22 +0,0 @@
-RSpec.describe StackMaster::TemplateCompilers::Cfndsl do
-
-  let(:compile_time_parameters) { {'InstanceType' => 't2.medium'} }
-
-  before(:all) { described_class.require_dependencies }
-
-  describe '.compile' do
-    def compile
-      described_class.compile(template_file_path, compile_time_parameters)
-    end
-
-    context 'valid cfndsl template' do
-      let(:template_file_path) { 'spec/fixtures/templates/rb/cfndsl/sample.rb' }
-      let(:valid_compiled_json_path) { 'spec/fixtures/templates/rb/cfndsl/sample.json' }
-
-      it 'produces valid JSON' do
-        valid_compiled_json = File.read(valid_compiled_json_path)
-        expect(JSON.parse(compile)).to eq(JSON.parse(valid_compiled_json))
-      end
-    end
-  end
-end

data/spec/stack_master/template_compilers/json_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe StackMaster::TemplateCompilers::Json do
-
-  let(:compile_time_parameters) { { 'InstanceType' => 't2.medium' } }
-
-  describe '.compile' do
-    def compile
-      described_class.compile(template_file_path, compile_time_parameters)
-    end
-
-    let(:template_file_path) { '/base_dir/templates/template.json' }
-
-    context "small json template" do
-      before do
-        allow(File).to receive(:read).with(template_file_path).and_return('{ }')
-      end
-
-      it "reads from the template file path" do
-        expect(compile).to eq('{ }')
-      end
-    end
-
-    context 'extra big json template' do
-      before do
-        allow(File).to receive(:read).with(template_file_path).and_return("{ #{' ' * 60000} }")
-      end
-
-      it "reads from the template file path" do
-        expect(compile).to eq('{}')
-      end
-    end
-  end
-end

data/spec/stack_master/template_compilers/sparkle_formation_spec.rb

@@ -1,116 +0,0 @@
-RSpec.describe StackMaster::TemplateCompilers::SparkleFormation do
-
-  describe '.compile' do
-    def compile
-      described_class.compile(template_file_path, compile_time_parameters, compiler_options)
-    end
-
-    let(:template_file_path) { '/base_dir/templates/template.rb' }
-    let(:compile_time_parameters) { {'Ip' => '10.0.0.0', 'Name' => 'Something'} }
-    let(:compiler_options) { {} }
-    let(:compile_time_parameter_definitions) { {} }
-
-    let(:sparkle_template) { instance_double(::SparkleFormation) }
-    let(:definitions_validator) { instance_double(StackMaster::SparkleFormation::CompileTime::DefinitionsValidator) }
-    let(:parameters_validator) { instance_double(StackMaster::SparkleFormation::CompileTime::ParametersValidator) }
-    let(:state_builder) { instance_double(StackMaster::SparkleFormation::CompileTime::StateBuilder) }
-
-    let(:sparkle_double) { instance_double(::SparkleFormation::SparkleCollection) }
-
-    before do
-      allow(::SparkleFormation).to receive(:compile).with(template_file_path, :sparkle).and_return(sparkle_template)
-      allow(::SparkleFormation::Sparkle).to receive(:new)
-      allow(StackMaster::SparkleFormation::CompileTime::DefinitionsValidator).to receive(:new).and_return(definitions_validator)
-      allow(StackMaster::SparkleFormation::CompileTime::ParametersValidator).to receive(:new).and_return(parameters_validator)
-      allow(StackMaster::SparkleFormation::CompileTime::StateBuilder).to receive(:new).and_return(state_builder)
-      allow(::SparkleFormation::SparkleCollection).to receive(:new).and_return(sparkle_double)
-
-      allow(sparkle_template).to receive(:parameters).and_return(compile_time_parameter_definitions)
-      allow(sparkle_template).to receive(:sparkle).and_return(sparkle_double)
-      allow(sparkle_double).to receive(:apply)
-      allow(sparkle_double).to receive(:set_root)
-      allow(definitions_validator).to receive(:validate)
-      allow(parameters_validator).to receive(:validate)
-      allow(state_builder).to receive(:build).and_return({})
-      allow(sparkle_template).to receive(:compile_time_parameter_setter).and_yield
-      allow(sparkle_template).to receive(:compile_state=)
-      allow(sparkle_template).to receive(:to_json).and_return("{\n}")
-    end
-
-    it 'compiles with sparkleformation' do
-      expect(compile).to eq("{\n}")
-    end
-
-    it 'sets the appropriate sparkle_path' do
-      compile
-      expect(::SparkleFormation.sparkle_path).to eq File.dirname(template_file_path)
-    end
-
-    it 'should validate the compile time definitions' do
-      expect(StackMaster::SparkleFormation::CompileTime::DefinitionsValidator).to receive(:new).with(compile_time_parameter_definitions)
-      expect(definitions_validator).to receive(:validate)
-      compile
-    end
-
-    it 'should validate the parameters against any compile time definitions' do
-      expect(StackMaster::SparkleFormation::CompileTime::ParametersValidator).to receive(:new).with(compile_time_parameter_definitions, compile_time_parameters)
-      expect(parameters_validator).to receive(:validate)
-      compile
-    end
-
-    it 'should create the compile state' do
-      expect(StackMaster::SparkleFormation::CompileTime::StateBuilder).to receive(:new).with(compile_time_parameter_definitions, compile_time_parameters)
-      expect(state_builder).to receive(:build)
-      compile
-    end
-
-    it 'should set the compile state' do
-      expect(sparkle_template).to receive(:compile_state=).with({})
-      compile
-    end
-
-    context 'with a custom sparkle_path' do
-      let(:compiler_options) { {'sparkle_path' => '../foo'} }
-
-      it 'does not use the default path' do
-        compile
-        expect(::SparkleFormation.sparkle_path).to_not eq File.dirname(template_file_path)
-      end
-
-      it 'expands the given path' do
-        compile
-        expect(::SparkleFormation.sparkle_path).to match %r{^/.+/foo}
-      end
-    end
-
-  end
-
-  describe '.compile with sparkle packs' do
-    let(:compile_time_parameters) { {} }
-    subject(:compile) { described_class.compile(template_file_path, compile_time_parameters, compiler_options)}
-
-    context 'with a sparkle_pack loaded' do
-      let(:template_file_path) { File.join(File.dirname(__FILE__), "..", "..", "fixtures", "sparkle_pack_integration", "templates", "template_with_dynamic_from_pack.rb")}
-      let(:compiler_options) { {"sparkle_packs" => ["my_sparkle_pack"]} }
-
-      before do
-        lib =  File.join(File.dirname(__FILE__), "..", "..", "fixtures", "sparkle_pack_integration", "my_sparkle_pack", "lib")
-        puts "Loading from #{lib}"
-        $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-      end
-
-      it 'pulls the dynamic from the sparkle pack' do
-        expect(compile).to eq(%Q({\n  \"Outputs\": {\n    \"Foo\": {\n      \"Value\": \"bar\"\n    }\n  }\n}))
-      end
-    end
-
-    context 'without a sparkle_pack loaded' do
-      let(:template_file_path) { File.join(File.dirname(__FILE__), "..", "..", "fixtures", "sparkle_pack_integration", "templates", "template_with_dynamic.rb")}
-      let(:compiler_options) { {} }
-
-      it 'pulls the dynamic from the local path' do
-        expect(compile).to eq(%Q({\n  \"Outputs\": {\n    \"Bar\": {\n      \"Value\": \"local_dynamic\"\n    }\n  }\n}))
-      end
-    end
-  end
-end