stack_master 0.0.1

data/spec/stack_master/security_group_finder_spec.rb

@@ -0,0 +1,49 @@
+RSpec.describe StackMaster::SecurityGroupFinder do
+  subject(:finder) { described_class.new(region) }
+  let(:region) { 'us-east-1' }
+  let(:group_name) { "our-api-BeanstalkSg-T4RKD99YOY2F" }
+  let(:filter) do
+    {
+      filters: [
+        {
+          name: "group-name",
+          values: [group_name],
+        },
+      ],
+    }
+  end
+
+  describe "#find" do
+    before do
+      allow_any_instance_of(Aws::EC2::Resource).to receive(:security_groups).with(filter).and_return(security_groups)
+    end
+
+    context "one sg match" do
+      let(:security_groups) { [
+                                double(id: 'sg-a7d2ccc0')
+                              ] }
+      it "returns the id" do
+        expect(finder.find(group_name)).to eq 'sg-a7d2ccc0'
+      end
+    end
+
+    context "more than one sg matches" do
+      let(:security_groups) { [
+                                double(id: 'sg-a7d2ccc0'),
+                                double(id: 'sg-a7d2ccc2'),
+                              ] }
+      it "returns the id" do
+        err = StackMaster::SecurityGroupFinder::MultipleSecurityGroupsFound
+        expect { finder.find(group_name) }.to raise_error(err)
+      end
+    end
+
+    context "no matches" do
+      let(:security_groups) { [] }
+      it "returns the id" do
+        err = StackMaster::SecurityGroupFinder::SecurityGroupNotFound
+        expect { finder.find(group_name) }.to raise_error(err)
+      end
+    end
+  end
+end

data/spec/stack_master/sns_topic_finder_spec.rb

@@ -0,0 +1,25 @@
+RSpec.describe StackMaster::SnsTopicFinder do
+
+  subject(:finder) { described_class.new(region) }
+  let(:region) { 'us-east-1' }
+  let(:topics) do
+    [
+      double(arn: 'arn:aws:sns:us-east-1:581634149801:topic1name'),
+      double(arn: 'arn:aws:sns:us-east-1:581634149801:topic2name'),
+    ]
+  end
+  before do
+    allow_any_instance_of(Aws::SNS::Resource).to receive(:topics).and_return topics
+  end
+
+  describe '#find' do
+    it 'finds the topics that exist' do
+      expect(finder.find('topic1name')).to eq 'arn:aws:sns:us-east-1:581634149801:topic1name'
+      expect(finder.find('topic2name')).to eq 'arn:aws:sns:us-east-1:581634149801:topic2name'
+    end
+
+    it 'raises an exception for topics that do not exist' do
+      expect { finder.find('unknowntopics') }.to raise_error StackMaster::SnsTopicFinder::TopicNotFound
+    end
+  end
+end

data/spec/stack_master/stack_definition_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe StackMaster::StackDefinition do
+  subject(:stack_definition) do
+    StackMaster::StackDefinition.new(
+      region: region,
+      stack_name: stack_name,
+      template: template,
+      tags: tags,
+      base_dir: base_dir)
+  end
+
+  let(:region) { 'us-east-1' }
+  let(:stack_name) { 'stack_name' }
+  let(:template) { 'template.json' }
+  let(:tags) { {'environment' => 'production'} }
+  let(:base_dir) { '/base_dir' }
+
+  it 'has default and region specific parameter file locations' do
+    expect(stack_definition.parameter_files).to eq([
+      "/base_dir/parameters/#{stack_name}.yml",
+      "/base_dir/parameters/#{region}/#{stack_name}.yml"
+    ])
+  end
+
+  context 'with additional parameter lookup dirs' do
+    before do
+      stack_definition.send(:additional_parameter_lookup_dirs=, ['production'])
+    end
+
+    it 'includes a parameter lookup dir for it' do
+      expect(stack_definition.parameter_files).to eq([
+        "/base_dir/parameters/#{stack_name}.yml",
+        "/base_dir/parameters/#{region}/#{stack_name}.yml",
+        "/base_dir/parameters/production/#{stack_name}.yml"
+      ])
+    end
+  end
+end

data/spec/stack_master/stack_differ_spec.rb

@@ -0,0 +1,34 @@
+RSpec.describe StackMaster::StackDiffer do
+  subject(:differ) { described_class.new(proposed_stack, stack) }
+  let(:stack) { StackMaster::Stack.new(stack_name: stack_name,
+                                       region: region,
+                                       stack_id: 123,
+                                       template_body: '{}',
+                                       parameters: {}) }
+  let(:proposed_stack) { StackMaster::Stack.new(stack_name: stack_name,
+                                                region: region,
+                                                parameters: { 'param1' => 'hello'},
+                                                template_body: "{\"a\": 1}") }
+  let(:stack_name) { 'myapp-vpc' }
+  let(:region) { 'us-east-1' }
+
+  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

@@ -0,0 +1,65 @@
+RSpec.describe StackMaster::StackEvents::Fetcher do
+  let(:cf) { Aws::CloudFormation::Client.new }
+
+  before do
+    allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf)
+    allow(StackMaster::StackEvents::Streamer).to receive(:stream)
+  end
+
+  context 'with 2 stack events' do
+    let(:events) { [
+      { event_id: '1', stack_id: '1', stack_name: 'blah', timestamp: Time.now},
+      { event_id: '2', stack_id: '1', stack_name: 'blah', timestamp: Time.now}
+    ] }
+
+    before do
+      cf.stub_responses(:describe_stack_events, stack_events: events)
+    end
+
+    it 'returns stack events' do
+      events = StackMaster::StackEvents::Fetcher.fetch('blah', 'us-east-1')
+      expect(events.count).to eq 2
+    end
+  end
+
+  context 'when more than one page is present' do
+    let(:page_one_events) { [
+      { event_id: '1', stack_id: '1', stack_name: 'blah', timestamp: Time.now},
+      { event_id: '2', stack_id: '1', stack_name: 'blah', timestamp: Time.now}
+    ] }
+    let(:page_two_events) { [
+      { event_id: '3', stack_id: '1', stack_name: 'blah', timestamp: Time.now}
+    ] }
+
+    before do
+      cf.stub_responses(:describe_stack_events, { stack_events: page_one_events, next_token: 'blah' }, { stack_events: page_two_events } )
+    end
+
+    it 'returns all the stack events combined' do
+      events = StackMaster::StackEvents::Fetcher.fetch('blah', 'us-east-1')
+      expect(events.count).to eq 3
+    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) {
+      [
+        { event_id: '1', stack_id: '1', stack_name: 'blah', timestamp: two_pm },
+        { event_id: '2', stack_id: '1', stack_name: 'blah', timestamp: four_pm },
+      ]
+    }
+
+    before do
+      cf.stub_responses(:describe_stack_events, stack_events: events)
+    end
+
+    it 'only returns events after the timestamp' do
+      events = StackMaster::StackEvents::Fetcher.fetch('blah', '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

@@ -0,0 +1,18 @@
+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 +1100 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

@@ -0,0 +1,33 @@
+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
+end

data/spec/stack_master/stack_spec.rb

@@ -0,0 +1,157 @@
+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']}])
+        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 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'], 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) { { 'DbPassword' => { 'secret' => 'db_password' } } }
+    let(:resolved_parameters) { { 'DbPassword' => 'sdfgjkdhlfjkghdflkjghdflkjg', 'InstanceType' => 't2.medium' } }
+    let(:template_file_name) { 'template.rb' }
+    let(:template_body) { '{"Parameters": { "VpcId": { "Description": "VPC ID" }, "InstanceType": { "Description": "Instance Type", "Default": "t2.micro" }} }' }
+    let(:stack_policy_body) { '{}' }
+
+    before do
+      allow(StackMaster::ParameterLoader).to receive(:load).and_return(parameter_hash)
+      allow(StackMaster::ParameterResolver).to receive(:resolve).and_return(resolved_parameters)
+      allow(StackMaster::TemplateCompiler).to receive(:compile).with(stack_definition.template_file_path).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_parameters
+    end
+
+    it 'compiles the template body' do
+      expect(stack.template_body).to eq template_body
+    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 "#maybe_compressed_template_body" do
+    subject(:maybe_compressed_template_body) do
+      stack.maybe_compressed_template_body
+    end
+    context "undersized json" do
+      let(:stack) { described_class.new(template_body: '{     }' ) }
+
+      it "leaves the json alone if it's not too large" do
+        expect(maybe_compressed_template_body).to eq('{     }')
+      end
+    end
+
+    context "oversized json" do
+      let(:stack) { described_class.new(template_body: "{#{' ' * 60000}}" ) }
+      it "compresses the json when it's overly bulbous" do
+        expect(maybe_compressed_template_body).to eq('{}')
+      end
+    end
+  end
+
+  describe '#too_big?' do
+    let(:big_stack) { described_class.new(template_body: "{\"a\":\"#{'x' * 60000}\"}") }
+    let(:little_stack) { described_class.new(template_body: "{\"a\":\"#{'x' * 1000}\"}") }
+
+    it 'returns true for big stacks' do
+      expect(big_stack.too_big?).to be_truthy
+    end
+    it 'returns false for small stacks' do
+      expect(little_stack.too_big?).to be_falsey
+    end
+  end
+end

data/spec/stack_master/template_compiler_spec.rb

@@ -0,0 +1,48 @@
+RSpec.describe StackMaster::TemplateCompiler do
+  describe ".compile" do
+    def compile
+      StackMaster::TemplateCompiler.compile(template_file_path)
+    end
+
+    context 'json template' do
+      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
+
+    context 'sparkleformation template' do
+      let(:template_file_path) { '/base_dir/templates/template.rb' }
+
+      before do
+        allow(SparkleFormation).to receive(:compile).with(template_file_path).and_return({})
+      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
+    end
+  end
+end