stack_master 1.5.0 → 1.6.0

data/spec/stack_master/commands/status_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe StackMaster::Commands::Status do
-  subject(:status) { described_class.new(config, false) }
-  let(:config) { instance_double(StackMaster::Config, stacks: stacks) }
-  let(:stacks) { [stack_definition_1, stack_definition_2] }
-  let(:stack_definition_1) { double(:stack_definition_1, region: 'us-east-1', stack_name: 'stack1') }
-  let(:stack_definition_2) { double(:stack_definition_2, region: 'us-east-1', stack_name: 'stack2', stack_status: 'CREATE_COMPLETE') }
-  let(:cf) { Aws::CloudFormation::Client.new(region: 'us-east-1') }
-
-  before do
-    allow(Aws::CloudFormation::Client).to receive(:new).with(region: 'us-east-1').and_return cf
-  end
-
-  context "#perform" do
-    before do
-      allow(StackMaster::Stack).to receive(:find).and_return stack1, stack2
-      allow(StackMaster::Stack).to receive(:generate).and_return proposed_stack1, proposed_stack2
-    end
-
-    context "some parameters are different" do
-      let(:stack1) { double(:stack1, template_body: '{}', template_hash: {}, template_format: :json, parameters_with_defaults: {a: 1}, stack_status: 'UPDATE_COMPLETE') }
-      let(:stack2) { double(:stack2, template_body: '{}', template_hash: {}, template_format: :json, parameters_with_defaults: {a: 2}, stack_status: 'CREATE_COMPLETE') }
-      let(:proposed_stack1) { double(:proposed_stack1, template_body: "{}", template_format: :json, parameters_with_defaults: {a: 1}) }
-      let(:proposed_stack2) { double(:proposed_stack2, template_body: "{}", template_format: :json, parameters_with_defaults: {a: 1}) }
-
-      it "returns the status of call stacks" do
-        out = "REGION    | STACK_NAME | STACK_STATUS    | DIFFERENT\n----------|------------|-----------------|----------\nus-east-1 | stack1     | UPDATE_COMPLETE | No       \nus-east-1 | stack2     | CREATE_COMPLETE | Yes      \n * No echo parameters can't be diffed\n"
-        expect { status.perform }.to output(out).to_stdout
-      end
-    end
-
-    context "some templates are different" do
-      let(:stack1) { double(:stack1, template_body: '{"foo": "bar"}', template_hash: {foo: 'bar'}, template_format: :json, parameters_with_defaults: {a: 1}, stack_status: 'UPDATE_COMPLETE') }
-      let(:stack2) { double(:stack2, template_body: '{}', template_hash: {}, template_format: :json, parameters_with_defaults: {a: 1}, stack_status: 'CREATE_COMPLETE') }
-      let(:proposed_stack1) { double(:proposed_stack1, template_body: "{}", template_format: :json, parameters_with_defaults: {a: 1}) }
-      let(:proposed_stack2) { double(:proposed_stack2, template_body: "{}", template_format: :json, parameters_with_defaults: {a: 1}) }
-
-      it "returns the status of call stacks" do
-        out = "REGION    | STACK_NAME | STACK_STATUS    | DIFFERENT\n----------|------------|-----------------|----------\nus-east-1 | stack1     | UPDATE_COMPLETE | Yes      \nus-east-1 | stack2     | CREATE_COMPLETE | No       \n * No echo parameters can't be diffed\n"
-        expect { status.perform }.to output(out).to_stdout
-      end
-    end
-  end
-
-end

data/spec/stack_master/commands/validate_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe StackMaster::Commands::Validate do
-
-  subject(:validate) { described_class.new(config, stack_definition, options) }
-  let(:config) { instance_double(StackMaster::Config) }
-  let(:region) { "us-east-1" }
-  let(:stack_name) { "mystack" }
-  let(:options) { }
-  let(:stack_definition) do
-    StackMaster::StackDefinition.new(
-      region: region,
-      stack_name: stack_name,
-      template: 'myapp_vpc.json',
-      tags: { 'environment' => 'production' },
-      base_dir: File.expand_path('spec/fixtures')
-    )
-  end
-
-  describe "#perform" do
-    context "can find stack" do
-      it "calls the validator to validate the stack definition" do
-        expect(StackMaster::Validator).to receive(:valid?).with(stack_definition, config)
-        validate.perform
-      end
-    end
-  end
-
-end

data/spec/stack_master/config_spec.rb

@@ -1,153 +0,0 @@
-RSpec.describe StackMaster::Config do
-  subject(:loaded_config) { StackMaster::Config.load!('spec/fixtures/stack_master.yml') }
-  let(:base_dir) { File.expand_path('spec/fixtures') }
-  let(:myapp_vpc_definition) {
-    StackMaster::StackDefinition.new(
-      region: 'us-east-1',
-      region_alias: 'production',
-      stack_name: 'myapp-vpc',
-      template: 'myapp_vpc.json',
-      tags: { 'application' => 'my-awesome-blog', 'environment' => 'production' },
-      s3: { 'bucket' => 'my-bucket', 'region' => 'us-east-1' },
-      notification_arns: ['test_arn', 'test_arn_2'],
-      role_arn: 'test_service_role_arn2',
-      base_dir: base_dir,
-      secret_file: 'production.yml.gpg',
-      stack_policy_file: 'my_policy.json',
-      additional_parameter_lookup_dirs: ['production']
-    )
-  }
-
-  describe ".load!" do
-    it "fails to load the config if no stack_master.yml in parent directories" do
-      expect { StackMaster::Config.load!('stack_master.yml') }.to raise_error Errno::ENOENT
-    end
-
-    it "searches up the tree for stack master yaml" do
-      begin
-        orig_dir = Dir.pwd
-        Dir.chdir './spec/fixtures/templates'
-        expect(StackMaster::Config.load!('stack_master.yml')).to_not be_nil
-      ensure
-        Dir.chdir orig_dir
-      end
-    end
-  end
-
-  describe '#find_stack' do
-    it 'returns an object that can find stack definitions' do
-      stack = loaded_config.find_stack('us-east-1', 'myapp-vpc')
-      expect(stack).to eq(myapp_vpc_definition)
-    end
-
-    it 'can find things with underscores instead of hyphens' do
-      stack = loaded_config.find_stack('us_east_1', 'myapp_vpc')
-      expect(stack).to eq(myapp_vpc_definition)
-    end
-  end
-
-  describe '#filter' do
-    it 'returns a list of stack definitions' do
-      stack = loaded_config.filter('us-east-1', 'myapp-vpc')
-      expect(stack).to eq([myapp_vpc_definition])
-    end
-
-    it 'can filter by region only' do
-      stacks = loaded_config.filter('us-east-1')
-      expect(stacks.size).to eq 3
-    end
-
-    it 'can return all stack definitions with no filters' do
-      stacks = loaded_config.filter
-      expect(stacks.size).to eq 5
-    end
-  end
-
-  it 'exposes the base_dir' do
-    expect(loaded_config.base_dir).to eq base_dir
-  end
-
-  it 'loads stack defaults' do
-    expect(loaded_config.stack_defaults).to eq({
-      'tags' => { 'application' => 'my-awesome-blog' },
-      's3' => { 'bucket' => 'my-bucket', 'region' => 'us-east-1' }
-    })
-  end
-
-  it 'loads template compiler mappings' do
-    expect(loaded_config.template_compilers).to eq({
-                                                     rb: :ruby_dsl,
-                                                     json: :json,
-                                                     yml: :yaml,
-                                                     yaml: :yaml,
-
-                                                   })
-  end
-
-  it 'loads region defaults' do
-    expect(loaded_config.region_defaults).to eq({
-      'us-east-1' => {
-        'tags' => { 'environment' => 'production' },
-        'role_arn' => 'test_service_role_arn',
-        'notification_arns' => ['test_arn'],
-        'secret_file' => 'production.yml.gpg',
-        'stack_policy_file' => 'my_policy.json'
-      },
-      'ap-southeast-2' => {
-        'tags' => {'environment' => 'staging', 'test_override' => 1 },
-        'role_arn' => 'test_service_role_arn3',
-        'notification_arns' => ['test_arn_3'],
-        'secret_file' => 'staging.yml.gpg'
-      }
-    })
-  end
-
-  it 'loads region_aliases' do
-    expect(loaded_config.region_aliases).to eq(
-      'production' => 'us-east-1',
-      'staging' => 'ap-southeast-2'
-    )
-  end
-
-  it 'deep merges stack attributes' do
-    expect(loaded_config.find_stack('ap-southeast-2', 'myapp-vpc')).to eq(StackMaster::StackDefinition.new(
-      stack_name: 'myapp-vpc',
-      region: 'ap-southeast-2',
-      region_alias: 'staging',
-      tags: {
-        'application' => 'my-awesome-blog',
-        'environment' => 'staging',
-        'test_override' => 1
-      },
-      s3: { 'bucket' => 'my-bucket', 'region' => 'us-east-1' },
-      role_arn: 'test_service_role_arn4',
-      notification_arns: ['test_arn_3', 'test_arn_4'],
-      template: 'myapp_vpc.rb',
-      base_dir: base_dir,
-      secret_file: 'staging.yml.gpg',
-      additional_parameter_lookup_dirs: ['staging']
-    ))
-    expect(loaded_config.find_stack('ap-southeast-2', 'myapp-web')).to eq(StackMaster::StackDefinition.new(
-      stack_name: 'myapp-web',
-      region: 'ap-southeast-2',
-      region_alias: 'staging',
-      tags: {
-        'application' => 'my-awesome-blog',
-        'environment' => 'staging',
-        'test_override' => 2
-      },
-      s3: { 'bucket' => 'my-bucket', 'region' => 'us-east-1' },
-      role_arn: 'test_service_role_arn3',
-      notification_arns: ['test_arn_3'],
-      template: 'myapp_web',
-      base_dir: base_dir,
-      secret_file: 'staging.yml.gpg',
-      additional_parameter_lookup_dirs: ['staging']
-    ))
-  end
-
-  it 'allows region aliases in region defaults' do
-    config = StackMaster::Config.new({'region_aliases' => { 'production' => 'us-east-1' }, 'region_defaults' => { 'production' => { 'secret_file' => 'production.yml.gpg' }}, 'stacks' => {}}, '/base')
-    expect(config.region_defaults).to eq('us-east-1' => { 'secret_file' => 'production.yml.gpg' })
-  end
-end

data/spec/stack_master/paged_response_accumulator_spec.rb

@@ -1,39 +0,0 @@
-RSpec.describe StackMaster::PagedResponseAccumulator do
-  let(:cf) { Aws::CloudFormation::Client.new }
-  subject(:accumulator) { described_class.new(cf, :describe_stack_events, { stack_name: 'blah' }, :stack_events) }
-
-  context 'with one page' 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}
-    ] }
-
-    before do
-      cf.stub_responses(:describe_stack_events, { stack_events: page_one_events, next_token: nil })
-    end
-
-    it 'returns the first page' do
-      events = accumulator.call
-      expect(events.stack_events.count).to eq 2
-    end
-  end
-
-  context 'with two pages' 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 = accumulator.call
-      expect(events.stack_events.count).to eq 3
-    end
-  end
-end

data/spec/stack_master/parameter_loader_spec.rb

@@ -1,110 +0,0 @@
-RSpec.describe StackMaster::ParameterLoader do
-  let(:stack_file_name) { '/base_dir/parameters/stack_name.yml' }
-  let(:region_file_name) { '/base_dir/parameters/us-east-1/stack_name.yml' }
-
-  subject(:parameters) { StackMaster::ParameterLoader.load([stack_file_name, region_file_name]) }
-
-  before do
-    file_mock(stack_file_name, stack_file_returns)
-    file_mock(region_file_name, region_file_returns)
-  end
-
-  context 'no parameter file' do
-    let(:stack_file_returns) { {exists: false} }
-    let(:region_file_returns) { {exists: false} }
-
-    it 'returns empty parameters' do
-      expect(parameters).to eq(template_parameters: {}, compile_time_parameters: {})
-    end
-  end
-
-  context 'an empty stack parameter file' do
-    let(:stack_file_returns) { {exists: true, read: ''} }
-    let(:region_file_returns) { {exists: false} }
-
-    it 'returns an empty hash' do
-      expect(parameters).to eq({template_parameters: {}, compile_time_parameters: {}})
-    end
-  end
-
-  context 'stack parameter file' do
-    let(:stack_file_returns) { {exists: true, read: 'Param1: value1'} }
-    let(:region_file_returns) { {exists: false} }
-
-    it 'returns params from stack_name.yml' do
-      expect(parameters).to eq(template_parameters: {'Param1' => 'value1'}, compile_time_parameters: {})
-    end
-  end
-
-  context 'region parameter file' do
-    let(:stack_file_returns) { {exists: false } }
-    let(:region_file_returns) { {exists: true, read: 'Param2: value2'} }
-
-    it 'returns params from the region base stack_name.yml' do
-      expect(parameters).to eq(template_parameters: {'Param2' => 'value2'}, compile_time_parameters: {})
-    end
-  end
-
-  context 'stack and region parameter file' do
-    let(:stack_file_returns) { {exists: true, read: "Param1: value1\nParam2: valueX" } }
-    let(:region_file_returns) { {exists: true, read: 'Param2: value2'} }
-
-    it 'returns params from the region base stack_name.yml' do
-      expect(parameters).to eq(template_parameters: {'Param1' => 'value1', 'Param2' => 'value2'}, compile_time_parameters: {})
-    end
-  end
-
-  context 'yml and yaml region parameter files' do
-    let(:stack_file_returns) { {exists: false} }
-    let(:region_file_returns) { {exists: true, read: "Param2: value2"} }
-    let(:region_yaml_file_returns) { {exists: true, read: "Param1: value1\nParam2: valueX"} }
-    let(:region_yaml_file_name) { "/base_dir/parameters/us-east-1/stack_name.yaml" }
-
-    subject(:parameters) { StackMaster::ParameterLoader.load([stack_file_name, region_yaml_file_name, region_file_name]) }
-
-    before do
-      file_mock(region_yaml_file_name, region_yaml_file_returns)
-    end
-
-    it 'returns params from the region base stack_name.yml' do
-      expect(parameters).to eq(template_parameters: {'Param1' => 'value1', 'Param2' => 'value2'}, compile_time_parameters: {})
-    end
-  end
-
-  context 'compile time parameters' do
-
-    context 'stack parameter file' do
-      let(:stack_file_returns) { {exists: true, read: "Param1: value1\nCompileTimeParameters:\n  Param2: value2" } }
-      let(:region_file_returns) { {exists: false} }
-
-      it 'returns params from stack_name.yml' do
-        expect(parameters).to eq(template_parameters: {'Param1' => 'value1'}, compile_time_parameters: {'Param2' => 'value2'})
-      end
-    end
-
-    context 'stack and region parameter file' do
-      let(:stack_file_returns) { {exists: true, read: "Param1: value1\nCompileTimeParameters:\n  Param2: valueX" } }
-      let(:region_file_returns) { {exists: true, read: "CompileTimeParameters:\n  Param2: value2"} }
-
-      it 'returns params from the region base stack_name.yml' do
-        expect(parameters).to eq(template_parameters: {'Param1' => 'value1'}, compile_time_parameters: {'Param2' => 'value2'})
-      end
-    end
-
-  end
-
-  context 'underscored parameter names' do
-    let(:stack_file_returns) { {exists: true, read: 'vpc_id: vpc-xxxxxx' } }
-    let(:region_file_returns) { {exists: false} }
-
-    it 'camelcases them' do
-      expect(parameters).to eq(template_parameters: {'VpcId' => 'vpc-xxxxxx'}, compile_time_parameters: {})
-    end
-  end
-
-  def file_mock(file_name, exists: false, read: nil)
-    allow(File).to receive(:exists?).with(file_name).and_return(exists)
-    allow(File).to receive(:read).with(file_name).and_return(read) if read
-  end
-
-end

data/spec/stack_master/parameter_resolver_spec.rb

@@ -1,148 +0,0 @@
-RSpec.describe StackMaster::ParameterResolver do
-  subject(:parameter_resolver) { StackMaster::ParameterResolver.new(config, region, params) }
-  let(:params) do
-    {
-      param: { my_resolver: 2 }
-    }
-  end
-  let(:config) { double }
-  let(:region) { 'us-east-1' }
-  let(:my_resolver) {
-    Class.new do
-      def initialize(config, region)
-      end
-
-      def resolve(value)
-        value.to_i * 5
-      end
-    end
-  }
-  let(:bad_resolver) {
-    Class.new do
-      def initialize(config, region)
-      end
-
-      def resolve(value)
-        raise Aws::CloudFormation::Errors::ValidationError.new(nil, "Can't find stack")
-      end
-    end
-  }
-
-  before do
-    stub_const('StackMaster::ParameterResolvers::MyResolver', my_resolver)
-    stub_const('StackMaster::ParameterResolvers::BadResolver', bad_resolver)
-  end
-
-  def resolve(params)
-    StackMaster::ParameterResolver.resolve(config, 'us-east-1', params)
-  end
-
-  it 'returns the same value for strings' do
-    expect(resolve(param1: 'value1')).to eq(param1: 'value1')
-  end
-
-  it 'returns integers as strings' do
-    expect(resolve(param1: 2)).to eq(param1: '2')
-  end
-
-  it 'joins arrays into comma separated strings' do
-    expect(resolve(param1: [1, 2])).to eq(param1: '1,2')
-  end
-
-  it 'converts boolean values to strings' do
-    expect(resolve(param1: true)).to eq(param1: 'true')
-    expect(resolve(param1: false)).to eq(param1: 'false')
-  end
-
-  it 'it throws an error when the hash contains more than one key' do
-    expect {
-      resolve(param: { nested1: 'value1', nested2: 'value2' })
-    }.to raise_error(StackMaster::ParameterResolver::InvalidParameter)
-  end
-
-  it "doesn't throw an error when given an array" do
-    expect {
-      resolve(param: [1, 2])
-    }.to_not raise_error
-  end
-
-  context 'when array values contain resolver hashes' do
-    it 'returns the comma separated string values returned by the resolvers' do
-      expect(resolve(param: [1, { my_resolver: 2 }])).to eq(param: '1,10')
-    end
-
-    it 'returns nested array values' do
-      expect(resolve(param: [[1, { my_resolver: 3 }], { my_resolver: 2 }])).to eq(param: '1,15,10')
-    end
-  end
-
-  context 'when given a proper resolve hash' do
-    it 'returns the value returned by the resolver as the parameter value' do
-      expect(resolve(param: { my_resolver: 2 })).to eq(param: 10)
-    end
-  end
-
-  context 'when the resolver is unknown' do
-    it 'throws an error' do
-      expect {
-        resolve(param: { my_unknown_resolver: 2 })
-      }.to raise_error StackMaster::ParameterResolver::ResolverNotFound
-    end
-  end
-
-  context 'when the resolver throws a ValidationError' do
-    it 'throws a invalid parameter error' do
-      expect {
-        resolve(param: { bad_resolver: 2 })
-      }.to raise_error StackMaster::ParameterResolver::InvalidParameter
-    end
-  end
-
-  context 'resolver class caching' do
-    it "uses the same instance of the resolver for the duration of the resolve run" do
-      expect(my_resolver).to receive(:new).once.and_call_original
-      expect(resolve(param: { my_resolver: 2 }, param2: { my_resolver: 2 })).to eq(param: 10, param2: 10)
-    end
-  end
-
-  context 'when the resolver class already exist' do
-    it 'does not try to load it' do
-      expect(parameter_resolver).to receive(:load_parameter_resolver).once.and_call_original
-      expect(parameter_resolver).not_to receive(:require_parameter_resolver)
-
-      parameter_resolver.resolve
-    end
-  end
-
-  context 'when the resolver class does not exist' do
-    let(:params) do
-      {
-        param: { dummy_resolver: 2 }
-      }
-    end
-
-    it 'tries to load it' do
-      expect(parameter_resolver).to receive(:load_parameter_resolver).once.and_call_original
-      expect(parameter_resolver).to receive(:require_parameter_resolver).and_return nil
-      expect(parameter_resolver).to receive(:call_resolver).and_return nil
-
-      parameter_resolver.resolve
-    end
-
-    context "using an array resolver" do
-      let(:params) do
-        {
-          param: { other_dummy_resolvers: [1, 2] }
-        }
-      end
-
-      it "tries to load the plural and singular forms" do
-        expect(parameter_resolver).to receive(:require_parameter_resolver).with("other_dummy_resolvers").once.and_call_original.ordered
-        expect(parameter_resolver).to receive(:require_parameter_resolver).with("other_dummy_resolver").once.ordered
-        expect(parameter_resolver).to receive(:call_resolver).and_return nil
-
-        parameter_resolver.resolve
-      end
-    end
-  end
-end