stack_master 1.5.0 → 1.6.0

data/spec/stack_master/parameter_resolvers/ami_finder_spec.rb

@@ -1,68 +0,0 @@
-RSpec.describe StackMaster::ParameterResolvers::AmiFinder do
-  subject(:resolver) { described_class.new('us-east-1') }
-  let(:ec2) { Aws::EC2::Client.new }
-
-  before do
-    allow(Aws::EC2::Client).to receive(:new).and_return(ec2)
-  end
-
-  describe '#build_filters_from_string' do
-    context 'when a single key-value pair is specified' do
-      it 'returns an array with a single hash' do
-        expect(resolver.build_filters_from_string('my-attr=my-value', nil)).to eq [
-          { name: 'my-attr', values: ['my-value']}
-        ]
-      end
-    end
-
-    context 'when multiple key-value pairs are specified' do
-      it 'returns an array with multiple hashes' do
-        expect(resolver.build_filters_from_string('my-attr=my-value,foo=bar', nil)).to eq [
-          { name: 'my-attr', values: ['my-value']},
-          { name: 'foo', values: ['bar']}
-        ]
-      end
-    end
-
-    context 'when a prefix is supplied' do
-      it 'adds the prefix to the filter' do
-        expect(resolver.build_filters_from_string('my-tag=my-value', 'tag')).to eq [
-          { name: 'tag:my-tag', values: ['my-value']}
-        ]
-      end
-    end
-  end
-
-  describe '#build_filters_from_hash' do
-    it 'outputs a hash of values in the format expected by the AWS API' do
-      expect(resolver.build_filters_from_hash({'foo' => 'bacon'})).to eq([{name: 'foo', values: ['bacon']}])
-    end
-  end
-
-  describe '#find_latest_ami' do
-    let(:filter) { [{ name: "String", values: ["String"]}] }
-
-    context 'when matches are found' do
-      before do
-        ec2.stub_responses(:describe_images, images: [
-          { image_id: '1', creation_date: '2015-01-02 00:00:00', tags: [{ key: 'my-tag', value: 'my-value' }] },
-          { image_id: '2', creation_date: '2015-01-03 00:00:00', tags: [{ key: 'my-tag', value: 'my-value' }] }
-        ])
-      end
-
-      it 'returns the latest one' do
-        expect(resolver.find_latest_ami(filter).image_id).to eq '2'
-      end
-    end
-
-    context 'when no matches are found' do
-      before do
-        ec2.stub_responses(:describe_images, images: [])
-      end
-
-      it 'returns nil' do
-        expect(resolver.find_latest_ami(filter)).to be_nil
-      end
-    end
-  end
-end

data/spec/stack_master/parameter_resolvers/env_spec.rb

@@ -1,35 +0,0 @@
-RSpec.describe StackMaster::ParameterResolvers::Env do
-
-  describe '#resolve' do
-
-    subject(:resolver) { described_class.new(nil, double(region: 'us-east-1')) }
-    let(:environment_variable_name) { 'TEST' }
-    let(:error) { "The environment variable #{environment_variable_name} is not set" }
-
-    before(:each) do
-      ENV.delete(environment_variable_name)
-    end
-
-    context 'the environment variable is defined' do
-      it 'should return the environment variable value' do
-        ENV[environment_variable_name] = 'a'
-        expect(resolver.resolve(environment_variable_name)).to eq 'a'
-      end
-    end
-
-    context 'the environment variable is undefined' do
-      it 'should raise and error' do
-        expect { resolver.resolve(environment_variable_name) }
-            .to raise_error(ArgumentError, error)
-      end
-    end
-
-    context 'the environment variable is defined but empty' do
-      it 'should return the empty string' do
-        ENV[environment_variable_name] = ''
-        expect(resolver.resolve(environment_variable_name)).to eq ''
-      end
-    end
-
-  end
-end

data/spec/stack_master/parameter_resolvers/latest_ami_by_tags_spec.rb

@@ -1,33 +0,0 @@
-RSpec.describe StackMaster::ParameterResolvers::LatestAmiByTags do
-  let(:config) { double(base_dir: '/base') }
-  let(:stack_definition) { double(stack_name: 'mystack', region: 'us-east-1') }
-  subject(:resolver) { described_class.new(config, stack_definition) }
-  let(:ec2) { Aws::EC2::Client.new }
-
-  before do
-    allow(Aws::EC2::Client).to receive(:new).and_return(ec2)
-  end
-
-  context 'when matches are found' do
-    before do
-      ec2.stub_responses(:describe_images, images: [
-        { image_id: '1', creation_date: '2015-01-02 00:00:00', tags: [{ key: 'my-tag', value: 'my-value' }] },
-        { image_id: '2', creation_date: '2015-01-03 00:00:00', tags: [{ key: 'my-tag', value: 'my-value' }] }
-      ])
-    end
-
-    it 'returns the latest one' do
-      expect(resolver.resolve('my-tag=my-value')).to eq '2'
-    end
-  end
-
-  context 'when no matches are found' do
-    before do
-      ec2.stub_responses(:describe_images, images: [])
-    end
-
-    it 'returns nil' do
-      expect(resolver.resolve('my-tag=my-value')).to be_nil
-    end
-  end
-end

data/spec/stack_master/parameter_resolvers/latest_ami_spec.rb

@@ -1,46 +0,0 @@
-RSpec.describe StackMaster::ParameterResolvers::LatestAmi do
-  let(:config) { double(base_dir: '/base') }
-  let(:stack_definition) { double(stack_name: 'mystack', region: 'us-east-1') }
-  subject(:resolver) { described_class.new(config, stack_definition) }
-  let(:ec2) { Aws::EC2::Client.new }
-
-  before do
-    allow(Aws::EC2::Client).to receive(:new).and_return(ec2)
-  end
-
-  context 'when matches are found' do
-    before do
-      ec2.stub_responses(:describe_images, images: [
-        { image_id: '1', creation_date: '2015-01-02 00:00:00', name: 'foo' },
-        { image_id: '2', creation_date: '2015-01-03 00:00:00', name: 'foo' }
-      ])
-    end
-
-    it 'returns the latest one' do
-      expect(resolver.resolve('filters' => {'name' => 'foo'})).to eq '2'
-    end
-  end
-
-  context 'when no matches are found' do
-    before do
-      ec2.stub_responses(:describe_images, images: [])
-    end
-
-    it 'returns nil' do
-      expect(resolver.resolve('filters' => {'name' => 'foo'})).to be_nil
-    end
-  end
-
-  context 'when an owner_id is passed' do
-    let(:ami_finder) { StackMaster::ParameterResolvers::AmiFinder.new('us-east-1') }
-    before do
-      expect(StackMaster::ParameterResolvers::AmiFinder).to receive(:new).and_return(ami_finder)
-      allow(ami_finder).to receive(:build_filters_from_hash).and_call_original
-    end
-
-    it 'calls find_latest_ami with the owner and filters' do
-      expect(ami_finder).to receive(:find_latest_ami).with([{name: 'foo', values: ['bacon']}], ['123456'])
-      resolver.resolve({'owners' => 123456, 'filters' => {'foo' => 'bacon'} })
-    end
-  end
-end

data/spec/stack_master/parameter_resolvers/parameter_store_spec.rb

@@ -1,50 +0,0 @@
-RSpec.describe StackMaster::ParameterResolvers::ParameterStore do
-
-  describe '#resolve' do
-
-    let(:config) { double(base_dir: '/base') }
-    let(:stack_definition) { double(stack_name: 'mystack', region: 'us-east-1') }
-    subject(:resolver) { described_class.new(config, stack_definition) }
-    let(:parameter_name) { 'TEST' }
-    let(:parameter_value) { 'TEST' }
-    let(:unknown_parameter_name) { 'NOTEST' }
-    let(:unencryptable_parameter_name) { 'SECRETTEST' }
-
-
-    context 'the parameter is defined' do
-      before do
-        Aws.config[:ssm] = {
-          stub_responses: {
-            get_parameter: {
-              parameter: {
-                name: parameter_name,
-                value: parameter_value,
-                type: "SecureString",
-                version: 1
-              }
-            }
-          }
-        }
-      end
-  
-      it 'should return the parameter value' do
-        expect(resolver.resolve(parameter_name)).to eq parameter_value
-      end
-    end
-
-    context 'the parameter is undefined' do
-      before do
-        Aws.config[:ssm] = {
-          stub_responses: {
-            get_parameter: 
-              Aws::SSM::Errors::ParameterNotFound.new(unknown_parameter_name, "Parameter #{unknown_parameter_name} not found")
-          }
-        }
-      end
-      it 'should raise and error' do
-        expect { resolver.resolve(unknown_parameter_name) }
-            .to raise_error(StackMaster::ParameterResolvers::ParameterStore::ParameterNotFound, "Unable to find #{unknown_parameter_name} in Parameter Store")
-      end
-    end
-  end
-end

data/spec/stack_master/parameter_resolvers/secret_spec.rb

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

@@ -1,19 +0,0 @@
-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
-      expect(finder).to receive(:find).once.with(sg_name).and_return sg_id
-    end
-
-    context 'when given a single SG name' do
-      it "resolves the security group" do
-        expect(resolver.resolve(sg_name)).to eq sg_id
-      end
-    end
-  end
-end

data/spec/stack_master/parameter_resolvers/security_groups_spec.rb

@@ -1,32 +0,0 @@
-RSpec.describe StackMaster::ParameterResolvers::SecurityGroups 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
-      expect(finder).to receive(:find).once.with(sg_name).and_return sg_id
-    end
-
-    context 'when given a single SG name' do
-      it "resolves the security group" do
-        expect(resolver.resolve(sg_name)).to eq sg_id
-      end
-    end
-
-    context 'when given a an array of SG names' do
-      let(:sg_id2) { 'sg-id2' }
-      let(:sg_name2) { 'sg-name2' }
-
-      before do
-        expect(finder).to receive(:find).once.with(sg_name2).and_return sg_id2
-      end
-
-      it "resolves the security groups" do
-        expect(resolver.resolve([sg_name, sg_name2])).to eq "#{sg_id},#{sg_id2}"
-      end
-    end
-  end
-end

data/spec/stack_master/parameter_resolvers/sns_topic_name_spec.rb

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

@@ -1,127 +0,0 @@
-RSpec.describe StackMaster::ParameterResolvers::StackOutput do
-  let(:region) { 'us-east-1' }
-  let(:stack_name) { 'my-stack' }
-  let(:resolver) { described_class.new(config, double(region: 'us-east-1')) }
-  let(:cf) { Aws::CloudFormation::Client.new }
-  let(:config) { double(:unalias_region => region) }
-
-  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
-
-  context 'when given a valid string value including region' do
-    let(:value) { 'us-east-1:my-stack/MyOutput' }
-    let(:stacks) { [{ stack_name: 'my-stack', 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
-
-      context 'the stack and output exist in a different region with the same name' do
-        let(:value_in_region_alias) { 'global:my-stack/MyOutput' }
-        let(:value_in_region_2) { 'ap-southeast-2:my-stack/MyOutput' }
-        let(:outputs_in_region_2) { [{output_key: 'MyOutput', output_value: 'myresolvedvalue2'}] }
-        let(:stacks_in_region_2) { [{ stack_name: 'my-stack', creation_time: Time.now, stack_status: 'CREATE_COMPLETE', outputs: outputs_in_region_2}] }
-
-        before do
-          cf.stub_responses(
-            :describe_stacks,
-            { stacks: stacks },
-            { stacks: stacks_in_region_2 }
-          )
-          allow(config).to receive(:unalias_region) do |aliased_region|
-            if aliased_region == 'global'
-              'us-east-1'
-            else
-              aliased_region
-            end
-          end
-        end
-
-        it 'resolves the value to the right region' do
-          resolver.resolve(value)
-          expect(resolver.resolve(value_in_region_2)).to eq 'myresolvedvalue2'
-        end
-
-        it 'resolves to the same region if it is an alias' do
-          expect(resolver.resolve(value_in_region_alias)).to eq 'myresolvedvalue'
-        end
-      end
-    end
-  end
-end