stack_master 1.5.0 → 1.6.0

data/spec/stack_master/change_set_spec.rb

@@ -1,70 +0,0 @@
-RSpec.describe StackMaster::ChangeSet do
-  let(:cf) { instance_double(Aws::CloudFormation::Client) }
-  let(:region) { 'us-east-1' }
-  let(:stack_name) { 'myapp-vpc' }
-  let(:change_set_name) { 'changeset-123' }
-
-  describe '.generate_change_set_name' do
-    context 'valid name' do
-      it 'creates a valid name' do
-        expect(StackMaster::ChangeSet.generate_change_set_name('foobar')).to match(/^foobar-StackMaster[-a-zA-Z0-9]*$/)
-      end
-    end
-  end
-
-  describe '.create' do
-    before do
-      allow(StackMaster::ChangeSet).to receive(:generate_change_set_name).and_return(change_set_name)
-      allow(StackMaster).to receive(:cloud_formation_driver).and_return(cf)
-      allow(cf).to receive(:create_change_set).and_return(double(id: 'id-1'))
-    end
-
-    context 'successful response' do
-      before do
-        allow(cf).to receive(:describe_change_set).with(change_set_name: 'id-1', next_token: nil).and_return(double(next_token: nil, changes: [], :changes= => nil, :next_token= => nil, status: 'CREATE_COMPLETE'))
-      end
-
-      it 'calls the create change set API with the addition of a name' do
-        change_set = StackMaster::ChangeSet.create(stack_name: '123')
-        expect(cf).to have_received(:create_change_set).with(
-          stack_name: '123',
-          change_set_name: change_set_name
-        )
-        expect(change_set.failed?).to eq false
-      end
-    end
-
-    context 'unsuccessful response' do
-      before do
-        allow(cf).to receive(:describe_change_set).with(change_set_name: 'id-1', next_token: nil).and_return(double(next_token: nil, changes: [], :changes= => nil, :next_token= => nil, status: 'FAILED', status_reason: 'No changes'))
-      end
-
-      it 'is marked as failed' do
-        change_set = StackMaster::ChangeSet.create(stack_name: '123')
-        expect(change_set.failed?).to eq true
-      end
-    end
-  end
-
-  describe '#display' do
-    context 'a successful response' do
-      let(:target) { OpenStruct.new(name: 'GroupDescription', attribute: 'Properties', requires_recreation: 'Always') }
-      let(:changes) { [
-        OpenStruct.new(resource_change: OpenStruct.new(replacement: 'True', action: 'Modify', resource_type: 'EC2::Instance', logical_resource_id: '123', details: [OpenStruct.new(target: target, change_source: 'DirectModification', evaluation: 'Static', causing_entity: 'blah')]))
-      ] }
-      let(:cf_response) { double(next_token: nil, changes: changes, :changes= => nil, :next_token= => nil, status: 'FAILED', status_reason: 'No changes') }
-      let(:io) { StringIO.new }
-      subject(:change_set) { StackMaster::ChangeSet.new(cf_response) }
-      let(:message) { io.string }
-      before { change_set.display(io) }
-
-      it 'outputs key data' do
-        expect(message).to include 'Replace EC2::Instance 123'
-      end
-
-      it 'outputs detail data' do
-        expect(message).to include 'Properties.GroupDescription. Always requires recreation. Triggered by: DirectModification.blah'
-      end
-    end
-  end
-end

data/spec/stack_master/command_spec.rb

@@ -1,66 +0,0 @@
-RSpec.describe StackMaster::Command do
-  let(:command_class) {
-    Class.new do
-      include StackMaster::Command
-
-      def initialize(callable = nil, halt = nil)
-        @callable = callable
-        @halt = halt
-      end
-
-      attr_reader :finished
-
-      def perform
-        instance_eval(&@callable) if @callable
-        halt! if @halt
-        @finished = true
-        false
-      end
-    end
-  }
-
-  context 'when failed is not called' do
-    it 'is successful' do
-      expect(command_class.perform.success?).to eq true
-    end
-  end
-
-  context 'when failed is called' do
-    it 'is not successful' do
-      expect(command_class.perform(proc { failed }).success?).to eq false
-    end
-  end
-
-  describe '#halt!' do
-    it 'exits the command' do
-      expect(command_class.perform(nil, true).finished).to_not eq true
-    end
-  end
-
-  context 'when a CF error occurs' do
-    it 'outputs the message' do
-      error_proc = proc {
-        raise Aws::CloudFormation::Errors::ServiceError.new('a', 'the message')
-      }
-      expect { command_class.perform(error_proc) }.to output(/the message/).to_stderr
-    end
-  end
-
-  context 'when a template compilation error occurs' do
-    it 'outputs the message' do
-      error_proc = proc {
-        raise StackMaster::TemplateCompiler::TemplateCompilationFailed.new('the message')
-      }
-      expect { command_class.perform(error_proc) }.to output(/the message/).to_stderr
-    end
-
-    it 'outputs the exception\'s cause' do
-      exception_with_cause = StackMaster::TemplateCompiler::TemplateCompilationFailed.new('the message')
-      allow(exception_with_cause).to receive(:cause).and_return(RuntimeError.new('the cause message'))
-      error_proc = proc {
-        raise exception_with_cause
-      }
-      expect { command_class.perform(error_proc) }.to output(/Caused by: RuntimeError the cause message/).to_stderr
-    end
-  end
-end

data/spec/stack_master/commands/apply_spec.rb

@@ -1,259 +0,0 @@
-RSpec.describe StackMaster::Commands::Apply do
-  let(:cf) { instance_double(Aws::CloudFormation::Client) }
-  let(:s3) { instance_double(Aws::S3::Client) }
-  let(:region) { 'us-east-1' }
-  let(:stack_name) { 'myapp-vpc' }
-  let(:config) { double(find_stack: stack_definition) }
-  let(:role_arn) { 'test_service_role_arn' }
-  let(:notification_arn) { 'test_arn' }
-  let(:stack_definition) { StackMaster::StackDefinition.new(base_dir: '/base_dir', region: region, stack_name: stack_name) }
-  let(:template_body) { '{}' }
-  let(:template_format) { :json }
-  let(:parameters) { { 'param_1' => 'hello' } }
-  let(:proposed_stack) { StackMaster::Stack.new(template_body: template_body, template_format: template_format, tags: { 'environment' => 'production' } , parameters: parameters, role_arn: role_arn, notification_arns: [notification_arn], stack_policy_body: stack_policy_body ) }
-  let(:stack_policy_body) { '{}' }
-  let(:change_set) { double(display: true, failed?: false, id: '1') }
-
-  before do
-    allow(StackMaster::Stack).to receive(:find).with(region, stack_name).and_return(stack)
-    allow(StackMaster::Stack).to receive(:generate).with(stack_definition, config).and_return(proposed_stack)
-    allow(config).to receive(:stack_defaults).and_return({})
-    allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf)
-    allow(Aws::S3::Client).to receive(:new).and_return(s3)
-    allow(cf).to receive(:create_stack)
-    allow(StackMaster::StackDiffer).to receive(:new).with(proposed_stack, stack).and_return double.as_null_object
-    allow(StackMaster::StackEvents::Streamer).to receive(:stream)
-    allow(StackMaster).to receive(:interactive?).and_return(false)
-    allow(cf).to receive(:create_change_set).and_return(OpenStruct.new(id: '1'))
-    allow(StackMaster::ChangeSet).to receive(:create).and_return(change_set)
-    allow(cf).to receive(:execute_change_set).and_return(OpenStruct.new(id: '1'))
-    allow(cf).to receive(:set_stack_policy)
-  end
-
-  def apply
-    StackMaster::Commands::Apply.perform(config, stack_definition)
-  end
-
-  context 'the stack exist' do
-    let(:stack) { StackMaster::Stack.new(stack_id: '1') }
-
-    it 'creates a change set' do
-      apply
-      expect(StackMaster::ChangeSet).to have_received(:create).with(
-        stack_name: stack_name,
-        template_body: proposed_stack.template_body,
-        parameters: [
-          { parameter_key: 'param_1', parameter_value: 'hello' }
-        ],
-        tags: [
-          { key: 'environment', value: 'production' }
-        ],
-        capabilities: ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
-        role_arn: role_arn,
-        notification_arns: [notification_arn]
-      )
-    end
-
-    it 'streams events' do
-      Timecop.freeze(Time.local(1990)) do
-        apply
-        expect(StackMaster::StackEvents::Streamer).to have_received(:stream).with(stack_name, region, io: STDOUT, from: Time.now)
-      end
-    end
-
-    it 'attaches a stack policy to the stack' do
-      apply
-      expect(cf).to have_received(:set_stack_policy).with(
-        stack_name: stack_name,
-        stack_policy_body: stack_policy_body
-      )
-    end
-
-    context 'stack policy is not changed' do
-      let(:stack) { StackMaster::Stack.new(stack_id: '1', stack_policy_body: stack_policy_body) }
-
-      it 'does not set a stack policy' do
-        apply
-        expect(cf).to_not have_received(:set_stack_policy)
-      end
-    end
-
-    context 'when using s3' do
-      before do
-        stack_definition.s3 = {
-          'bucket' => 'my-bucket',
-          'prefix' => 'my-prefix',
-          'region' => 'us-east-1',
-        }
-        stack_definition.template = 'my-template.rb'
-        allow(s3).to receive(:list_objects).and_return([])
-        allow(s3).to receive(:put_object)
-      end
-
-      it 'uploads to the correct URL' do
-        apply
-        expect(s3).to have_received(:put_object).with(
-          bucket: 'my-bucket',
-          key: 'my-prefix/my-template.json',
-          body: template_body,
-          metadata: { md5: Digest::MD5.hexdigest(template_body).to_s }
-        )
-      end
-
-      it 'uploads to S3 before creating a changeset' do
-        expect(s3).to receive(:put_object).ordered
-        expect(StackMaster::ChangeSet).to receive(:create).ordered
-        apply
-      end
-    end
-
-    context 'the changeset failed to create' do
-      before do
-        allow(StackMaster::ChangeSet).to receive(:delete)
-        allow(change_set).to receive(:failed?).and_return(true)
-        allow(change_set).to receive(:status_reason).and_return('reason')
-      end
-
-      it 'outputs the status reason' do
-        expect { apply }.to output(/reason/).to_stdout
-      end
-    end
-
-    context 'user decides to not apply the change set' do
-      before do
-        allow(StackMaster).to receive(:non_interactive_answer).and_return('n')
-        allow(StackMaster::ChangeSet).to receive(:delete)
-        allow(StackMaster::ChangeSet).to receive(:execute)
-        apply
-      end
-
-      it 'deletes the change set' do
-        expect(StackMaster::ChangeSet).to have_received(:delete).with(change_set.id)
-      end
-
-      it "doesn't execute the change set" do
-        expect(StackMaster::ChangeSet).to_not have_received(:execute).with(change_set.id)
-      end
-    end
-  end
-
-  context 'the stack does not exist' do
-    let(:stack) { nil }
-
-    it 'creates a change set for a new stack' do
-      apply
-      expect(StackMaster::ChangeSet).to have_received(:create).with(
-        stack_name: stack_name,
-        template_body: proposed_stack.template_body,
-        parameters: [
-          { parameter_key: 'param_1', parameter_value: 'hello' }
-        ],
-        tags: [
-          { key: 'environment', value: 'production' }
-        ],
-        capabilities: ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
-        role_arn: role_arn,
-        notification_arns: [notification_arn],
-        change_set_type: 'CREATE'
-      )
-    end
-
-    context 'on_failure option is set' do
-      it 'calls the create stack API method' do
-        options = Commander::Command::Options.new
-        options.on_failure = 'ROLLBACK'
-        StackMaster::Commands::Apply.perform(config, stack_definition, options)
-        apply
-        expect(cf).to have_received(:create_stack).with(
-          stack_name: stack_name,
-          template_body: proposed_stack.template_body,
-          parameters: [
-            { parameter_key: 'param_1', parameter_value: 'hello' }
-          ],
-          tags: [
-            { key: 'environment', value: 'production' }
-          ],
-          capabilities: ['CAPABILITY_IAM', 'CAPABILITY_NAMED_IAM'],
-          role_arn: role_arn,
-          notification_arns: [notification_arn],
-          on_failure: 'ROLLBACK'
-        )
-      end
-    end
-
-    it 'attaches a stack policy to the created stack' do
-      apply
-      expect(cf).to have_received(:set_stack_policy).with(
-        stack_name: stack_name,
-        stack_policy_body: stack_policy_body
-      )
-    end
-
-    context 'the stack is too large' do
-      let(:big_string) { 'x' * 60000 }
-      let(:template_body) do
-        "{\"a\":\"#{big_string}\"}"
-      end
-
-      it 'exits with a message' do
-        expect { apply }.to output(/The \(space compressed\) stack is larger than the limit set by AWS/).to_stderr
-      end
-    end
-
-    it 'streams events' do
-      Timecop.freeze(Time.local(1990)) do
-        apply
-        expect(StackMaster::StackEvents::Streamer).to have_received(:stream).with(stack_name, region, io: STDOUT, from: Time.now)
-      end
-    end
-
-    context 'user decides to not create a stack' do
-      before do
-        allow(StackMaster).to receive(:non_interactive_answer).and_return('n')
-        allow(cf).to receive(:delete_stack)
-        allow(StackMaster::ChangeSet).to receive(:execute)
-        apply
-      end
-
-      it 'deletes the stack' do
-        expect(cf).to have_received(:delete_stack).with(stack_name: stack_name)
-      end
-
-      it "doesn't execute the change set" do
-        expect(StackMaster::ChangeSet).to_not have_received(:execute).with(change_set.id)
-      end
-    end
-
-    context 'user uses ctrl+c' do
-      before do
-        allow(StackMaster).to receive(:non_interactive_answer).and_return('n')
-        allow(cf).to receive(:delete_stack)
-        allow(StackMaster::ChangeSet).to receive(:create).and_raise(StackMaster::CtrlC)
-      end
-
-      it "deletes the stack" do
-        expect(cf).to receive(:delete_stack).with(stack_name: stack_name)
-        expect { apply }.to raise_error
-      end
-    end
-  end
-
-  context 'one or more parameters are empty' do
-    let(:stack) { StackMaster::Stack.new(stack_id: '1', parameters: parameters) }
-    let(:parameters) { { 'param_1' => nil } }
-
-    it "doesn't allow apply" do
-      expect { apply }.to_not output(/Continue and apply the stack/).to_stdout
-    end
-
-    it 'outputs a description of the problem' do
-      expect { apply }.to output(/Empty\/blank parameters detected/).to_stderr
-    end
-
-    it 'outputs where param files are loaded from' do
-      stack_definition.parameter_files.each do |parameter_file|
-        expect { apply }.to output(/#{parameter_file}/).to_stderr
-      end
-    end
-  end
-end

data/spec/stack_master/commands/delete_spec.rb

@@ -1,40 +0,0 @@
-RSpec.describe StackMaster::Commands::Delete do
-
-  subject(:delete) { described_class.new(stack_name, region) }
-  let(:cf) { Aws::CloudFormation::Client.new }
-  let(:region) { 'us-east-1' }
-  let(:stack_name) { 'mystack' }
-
-  before do
-    StackMaster.cloud_formation_driver.set_region(region)
-    allow(Aws::CloudFormation::Client).to receive(:new).with(region: region, retry_limit: 10).and_return(cf)
-    allow(delete).to receive(:ask?).and_return('y')
-    allow(StackMaster::StackEvents::Streamer).to receive(:stream)
-  end
-
-  describe "#perform" do
-    context "The stack exists" do
-      before do
-        cf.stub_responses(:describe_stacks, stacks: [{ stack_id: "ABC", stack_name: stack_name, creation_time: Time.now, stack_status: 'UPDATE_COMPLETE', parameters: []}])
-
-      end
-      it "deletes the stack and tails the events" do
-        expect(cf).to receive(:delete_stack).with({:stack_name => region})
-        expect(StackMaster::StackEvents::Streamer).to receive(:stream)
-        delete.perform
-      end
-    end
-
-    context "The stack does not exist" do
-      before do
-        cf.stub_responses(:describe_stacks, Aws::CloudFormation::Errors::ValidationError.new("x", "y"))
-      end
-      it "raises an error" do
-        expect(StackMaster::StackEvents::Streamer).to_not receive(:stream)
-        expect(cf).to_not receive(:delete_stack)
-        delete.perform
-      end
-    end
-  end
-
-end

data/spec/stack_master/commands/init_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe StackMaster::Commands::Init do
-
-  subject(:init_command) { described_class.new(false, region, stack_name) }
-  let(:region) { "us-east-1" }
-  let(:stack_name) { "test-stack" }
-
-  describe "#perform" do
-    it "creates all the expected files" do
-      expect(IO).to receive(:write).with("stack_master.yml", "stacks:\n  us-east-1:\n    test-stack:\n      template: test-stack.json\n      tags:\n        environment: production\n")
-      expect(IO).to receive(:write).with("parameters/test_stack.yml", "# Add parameters here:\n# param1: value1\n# param2: value2\n")
-      expect(IO).to receive(:write).with("parameters/us-east-1/test_stack.yml", "# Add parameters here:\n# param1: value1\n# param2: value2\n")
-      expect(IO).to receive(:write).with("templates/test-stack.json", "{\n  \"AWSTemplateFormatVersion\" : \"2010-09-09\",\n  \"Description\" : \"Cloudformation stack for test-stack\",\n\n  \"Parameters\" : {\n    \"InstanceType\" : {\n      \"Description\" : \"EC2 instance type\",\n      \"Type\" : \"String\"\n    }\n  },\n\n  \"Mappings\" : {\n  },\n\n  \"Resources\" : {\n  },\n\n  \"Outputs\" : {\n  }\n}\n")
-      init_command.perform()
-    end
-  end
-
-end