stack_master 0.0.1

data/spec/stack_master/commands/validate_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe StackMaster::Commands::Validate do
+
+  subject(:validate) { described_class.new(config, stack_definition) }
+  let(:config) { instance_double(StackMaster::Config) }
+  let(:region) { "us-east-1" }
+  let(:stack_name) { "mystack" }
+  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(:perform).with(stack_definition)
+        validate.perform
+      end
+    end
+  end
+
+end

data/spec/stack_master/config_spec.rb

@@ -0,0 +1,81 @@
+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',
+      stack_name: 'myapp-vpc',
+      template: 'myapp_vpc.json',
+      tags: { 'application' => 'my-awesome-blog', 'environment' => 'production' },
+      notification_arns: ['test_arn', 'test_arn_2'],
+      base_dir: base_dir,
+      secret_file: 'production.yml.gpg',
+      stack_policy_file: 'my_policy.json',
+      additional_parameter_lookup_dirs: ['production']
+    )
+  }
+
+  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
+
+  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' }
+    })
+  end
+
+  it 'loads region defaults' do
+    expect(loaded_config.region_defaults).to eq({
+      'us-east-1' => {
+        'tags' => { 'environment' => 'production' },
+        'notification_arns' => ['test_arn'],
+        'secret_file' => 'production.yml.gpg',
+        'stack_policy_file' => 'my_policy.json'
+      },
+      'ap-southeast-2' => {
+        'tags' => {'environment' => 'staging'},
+        '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',
+      tags: {
+        'application' => 'my-awesome-blog',
+        'environment' => 'staging'
+      },
+      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']
+    ))
+  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/parameter_loader_spec.rb

@@ -0,0 +1,81 @@
+RSpec.describe StackMaster::ParameterLoader do
+  subject(:parameters) { StackMaster::ParameterLoader.load(parameter_files) }
+  let(:parameter_files) { [
+    '/base_dir/parameters/stack_name.yml',
+    '/base_dir/parameters/us-east-1/stack_name.yml'
+  ] }
+
+  context "no parameter file" do
+    before do
+      allow(File).to receive(:exists?).and_return(false)
+    end
+
+    it "returns empty parameters" do
+      expect(parameters).to eq({})
+    end
+  end
+
+  context "an empty stack parameter file" do
+    before do
+      allow(File).to receive(:exists?).with('/base_dir/parameters/stack_name.yml').and_return(true)
+      allow(File).to receive(:exists?).with('/base_dir/parameters/us-east-1/stack_name.yml').and_return(false)
+      allow(File).to receive(:read).with('/base_dir/parameters/stack_name.yml').and_return("")
+    end
+
+    it "returns an empty hash" do
+      expect(parameters).to eq({})
+    end
+  end
+
+  context "stack parameter file" do
+    before do
+      allow(File).to receive(:exists?).with('/base_dir/parameters/stack_name.yml').and_return(true)
+      allow(File).to receive(:exists?).with('/base_dir/parameters/us-east-1/stack_name.yml').and_return(false)
+      allow(File).to receive(:read).with('/base_dir/parameters/stack_name.yml').and_return("Param1: value1")
+    end
+
+    it "returns params from stack_name.yml" do
+      expect(parameters).to eq({ 'Param1' => 'value1' })
+    end
+  end
+
+  context "region parameter file" do
+    before do
+      allow(File).to receive(:exists?).with('/base_dir/parameters/stack_name.yml').and_return(false)
+      allow(File).to receive(:exists?).with('/base_dir/parameters/us-east-1/stack_name.yml').and_return(true)
+      allow(File).to receive(:read).with('/base_dir/parameters/us-east-1/stack_name.yml').and_return("Param2: value2")
+    end
+
+    it "returns params from the region base stack_name.yml" do
+      expect(parameters).to eq({ 'Param2' => 'value2' })
+    end
+  end
+
+  context "stack and region parameter file" do
+    before do
+      allow(File).to receive(:exists?).with('/base_dir/parameters/stack_name.yml').and_return(true)
+      allow(File).to receive(:exists?).with('/base_dir/parameters/us-east-1/stack_name.yml').and_return(true)
+      allow(File).to receive(:read).with('/base_dir/parameters/stack_name.yml').and_return("Param1: value1\nParam2: valueX")
+      allow(File).to receive(:read).with('/base_dir/parameters/us-east-1/stack_name.yml').and_return("Param2: value2")
+    end
+
+    it "returns params from the region base stack_name.yml" do
+      expect(parameters).to eq({
+                                                  'Param1' => 'value1',
+                                                  'Param2' => 'value2'
+                                                })
+    end
+  end
+
+  context 'underscored parameter names' do
+    before do
+      allow(File).to receive(:exists?).with('/base_dir/parameters/stack_name.yml').and_return(true)
+      allow(File).to receive(:exists?).with('/base_dir/parameters/us-east-1/stack_name.yml').and_return(false)
+      allow(File).to receive(:read).with('/base_dir/parameters/stack_name.yml').and_return("vpc_id: vpc-xxxxxx")
+    end
+
+    it "camelcases them" do
+      expect(parameters).to eq({'VpcId' => 'vpc-xxxxxx'})
+    end
+  end
+end

data/spec/stack_master/parameter_resolver_spec.rb

@@ -0,0 +1,58 @@
+RSpec.describe StackMaster::ParameterResolver do
+  let(:config) { double }
+  let(:my_resolver) {
+    Class.new do
+      def initialize(config, region)
+      end
+
+      def resolve(value)
+        value.to_i * 5
+      end
+    end
+  }
+  before do
+    stub_const('StackMaster::ParameterResolvers::MyResolver', my_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 '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 'throws an error when given an array' do
+    expect {
+      resolve(param: [1, 2])
+    }.to raise_error(StackMaster::ParameterResolver::InvalidParameter)
+  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 '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
+end

data/spec/stack_master/parameter_resolvers/secret_spec.rb

@@ -0,0 +1,66 @@
+RSpec.describe StackMaster::ParameterResolvers::Secret do
+  let(:base_dir) { '/base_dir' }
+  let(:config) { double(base_dir: base_dir) }
+  let(:stack_definition) { double(secret_file: secrets_file_name, stack_name: 'mystack', region: 'us-east-1') }
+  subject(:resolve_secret) { StackMaster::ParameterResolvers::Secret.new(config, stack_definition).resolve(value) }
+  let(:value) { 'my_file/my_secret_key' }
+  let(:secrets_file_name) { "my_file.yml.gpg" }
+  let(:file_path) { "#{base_dir}/secrets/#{secrets_file_name}" }
+
+  context 'the secret file does not exist' do
+    before do
+      allow(File).to receive(:exist?).with(file_path).and_return(false)
+    end
+
+    it 'raises an ArgumentError with the location of the expected secret file' do
+      expect {
+        resolve_secret
+      }.to raise_error(ArgumentError, /#{file_path}/)
+    end
+  end
+
+  context 'no secret file is specified for the stack definition' do
+    before do
+      allow(stack_definition).to receive(:secret_file).and_return(nil)
+    end
+
+    it 'raises an ArgumentError with the location of the expected secret file' do
+      expect {
+        resolve_secret
+      }.to raise_error(ArgumentError, /No secret_file defined/)
+    end
+  end
+
+  context 'the secret file exists' do
+    let(:dir) { double(Dotgpg::Dir) }
+    let(:decrypted_file) { <<EOF }
+secret_key_1: secret_value_1
+secret_key_2: secret_value_2
+EOF
+
+    before do
+      allow(File).to receive(:exist?).with(file_path).and_return(true)
+      allow(Dotgpg::Dir).to receive(:closest).with(file_path).and_return(dir)
+      allow(dir).to receive(:decrypt).with("secrets/#{secrets_file_name}", anything)
+      allow(StringIO).to receive(:new).and_return(double(string: decrypted_file))
+    end
+
+    context 'the secret key does not exist' do
+      let(:value) { 'unknown_secret' }
+
+      it 'raises a secret not found error' do
+        expect {
+          resolve_secret
+        }.to raise_error(StackMaster::ParameterResolvers::Secret::SecretNotFound)
+      end
+    end
+
+    context 'the secret key exists' do
+      let(:value) { 'secret_key_2' }
+
+      it 'returns the secret' do
+        expect(resolve_secret).to eq('secret_value_2')
+      end
+    end
+  end
+end

data/spec/stack_master/parameter_resolvers/security_group_spec.rb

@@ -0,0 +1,17 @@
+RSpec.describe StackMaster::ParameterResolvers::SecurityGroup do
+  describe "#resolve" do
+    subject(:resolver) { described_class.new(nil, double(region: 'us-east-1')) }
+    let(:finder) { instance_double(StackMaster::SecurityGroupFinder) }
+    let(:sg_id) { 'sg-id' }
+    let(:sg_name) { 'sg-name' }
+
+    before do
+      allow(StackMaster::SecurityGroupFinder).to receive(:new).with('us-east-1').and_return finder
+      allow(finder).to receive(:find).with(sg_name).and_return sg_id
+    end
+
+    it "resolves the security group" do
+      expect(resolver.resolve(sg_name)).to eq sg_id
+    end
+  end
+end

data/spec/stack_master/parameter_resolvers/sns_topic_name_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe StackMaster::ParameterResolvers::SnsTopicName do
+  let(:region) { 'us-east-1' }
+  let(:stack_name) { 'my-stack' }
+  let(:config) { double }
+
+  def resolve(value)
+    described_class.new(config, double(region: 'us-east-1')).resolve(value)
+  end
+
+  subject(:resolved_value) { resolve(value) }
+
+  context 'when given a hash' do
+    let(:value) { { not_expected: 1} }
+
+    it 'raises an error' do
+      expect {
+        resolved_value
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when given a string value' do
+    let(:value) { 'my-topic-name' }
+
+    context 'the stack and sns topic name exist' do
+      before do
+        allow_any_instance_of(StackMaster::SnsTopicFinder).to receive(:find).with(value).and_return('myresolvedvalue')
+      end
+
+      it 'resolves the value' do
+        expect(resolved_value).to eq 'myresolvedvalue'
+      end
+    end
+
+    context "the topic doesn't exist" do
+      it 'raises topic not found' do
+        expect {
+          resolved_value
+        }.to raise_error(StackMaster::ParameterResolvers::SnsTopicName::TopicNotFound)
+      end
+    end
+  end
+end

data/spec/stack_master/parameter_resolvers/stack_output_spec.rb

@@ -0,0 +1,77 @@
+RSpec.describe StackMaster::ParameterResolvers::StackOutput do
+  let(:region) { 'us-east-1' }
+  let(:stack_name) { 'my-stack' }
+  let(:config) { double }
+  let(:resolver) { described_class.new(config, double(region: 'us-east-1')) }
+  let(:cf) { Aws::CloudFormation::Client.new }
+
+  def resolve(value)
+    resolver.resolve(value)
+  end
+
+  subject(:resolved_value) { resolve(value) }
+
+  context 'when given an invalid string value' do
+    let(:value) { 'stack-name-without-output' }
+
+    it 'raises an error' do
+      expect {
+        resolved_value
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when given a hash' do
+    let(:value) { { not_expected: 1} }
+
+    it 'raises an error' do
+      expect {
+        resolved_value
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when given a valid string value' do
+    let(:value) { 'my-stack/MyOutput' }
+    let(:stacks) { [{ stack_name: 'blah', creation_time: Time.now, stack_status: 'CREATE_COMPLETE', outputs: outputs}] }
+    let(:outputs) { [] }
+
+    before do
+      allow(Aws::CloudFormation::Client).to receive(:new).and_return(cf)
+      cf.stub_responses(:describe_stacks, stacks: stacks)
+    end
+
+    context 'the stack and output exist' do
+      let(:outputs) { [{output_key: 'MyOutput', output_value: 'myresolvedvalue'}] }
+
+      it 'resolves the value' do
+        expect(resolved_value).to eq 'myresolvedvalue'
+      end
+
+      it 'caches stacks for the lifetime of the instance' do
+        resolver.resolve(value)
+        resolver.resolve(value)
+      end
+    end
+
+    context "the stack doesn't exist" do
+      let(:stacks) { nil }
+
+      it 'resolves the value' do
+        expect {
+          resolved_value
+        }.to raise_error(StackMaster::ParameterResolvers::StackOutput::StackNotFound)
+      end
+    end
+
+    context "the output doesn't exist" do
+      let(:outputs) { [] }
+
+      it 'resolves the value' do
+        expect {
+          resolved_value
+        }.to raise_error(StackMaster::ParameterResolvers::StackOutput::StackOutputNotFound)
+      end
+    end
+  end
+end