stack_master 1.5.0 → 1.6.0

data/spec/stack_master/prompter_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe StackMaster::Prompter do
-  include StackMaster::Prompter
-
-  context 'when STDIN is not a TTY' do
-    before do
-      allow(StackMaster.stdin).to receive(:tty?).and_return(false)
-    end
-
-    it 'defaults to no and outputs info about -y' do
-      expect { ask?('blah') }.to output(/To force yes use -y/).to_stdout
-    end
-  end
-
-  context 'when STDOUT is not a TTY' do
-    before do
-      allow(StackMaster.stdout).to receive(:tty?).and_return(false)
-    end
-
-    it 'defaults to no and outputs info about -y' do
-      expect { ask?('blah') }.to output(/To force yes use -y/).to_stdout
-    end
-  end
-end

data/spec/stack_master/resolver_array_spec.rb

@@ -1,42 +0,0 @@
-require 'stack_master/resolver_array'
-
-RSpec.shared_examples_for 'a resolver' do
-  it 'should create a TestResolvers class' do
-    expect(array_resolver_class).to be_a Class
-  end
-
-  it 'should have TestResolver as a resolver class' do
-    expect(array_resolver_instance).to respond_to :resolver_class
-    expect(array_resolver_instance.resolver_class).to be TestResolver
-  end
-end
-
-RSpec.describe 'StackMaster::ParameterResolvers::Resolver' do
-  let(:array_resolver_instance) { array_resolver_class.new(nil, nil) }
-
-  describe '.array_resolver' do
-    context 'when using a default name' do
-      before do 
-        class TestResolver < StackMaster::ParameterResolvers::Resolver
-          array_resolver
-        end
-      end
-
-      let(:array_resolver_class) { StackMaster::ParameterResolvers::TestResolvers }
-
-      it_behaves_like 'a resolver'
-    end
-
-    context 'when using a specific name' do
-      before do 
-        class TestResolver < StackMaster::ParameterResolvers::Resolver
-          array_resolver class_name: 'SpecificResolver'
-        end
-      end
-      
-      let(:array_resolver_class) { StackMaster::ParameterResolvers::SpecificResolver }
-
-      it_behaves_like 'a resolver'
-    end
-  end
-end

data/spec/stack_master/security_group_finder_spec.rb

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

@@ -1,25 +0,0 @@
-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/sparkle_formation/compile_time/allowed_pattern_validator_spec.rb

@@ -1,47 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::AllowedPatternValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, definition) { "#{name}:#{error} does not match allowed_pattern:#{definition[:allowed_pattern]}" } }
-
-    context 'string validation' do
-      let(:definition) { {type: :string, allowed_pattern: '^a'} }
-      validate_valid_parameter('a')
-      validate_valid_parameter(['a'])
-      validate_invalid_parameter('b', ['b'])
-      validate_invalid_parameter(['b'], ['b'])
-    end
-
-    context 'string validation with default' do
-      let(:definition) { {type: :string, allowed_pattern: '^a', default: 'a'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'string validation with multiple' do
-      let(:definition) { {type: :string, allowed_pattern: '^a', multiple: true} }
-      validate_valid_parameter('a,ab')
-      validate_invalid_parameter('a,,ab', [''])
-      validate_invalid_parameter('a, ,ab', [''])
-    end
-
-    context 'string validation with multiple default values' do
-      let(:definition) { {type: :string, allowed_pattern: '^a', multiple: true, default:'a,a'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number, allowed_pattern: '^1'} }
-      validate_valid_parameter(1)
-      validate_valid_parameter('1')
-      validate_valid_parameter([1])
-      validate_valid_parameter(['1'])
-      validate_invalid_parameter(2, [2])
-      validate_invalid_parameter('2', ['2'])
-    end
-
-    context 'validation with default value' do
-      let(:definition) { {type: :number, allowed_pattern: '^1', default: '1'} }
-      validate_valid_parameter(nil)
-    end
-  end
-end

data/spec/stack_master/sparkle_formation/compile_time/allowed_values_validator_spec.rb

@@ -1,47 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::AllowedValuesValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, definition) { "#{name}:#{error} is not in allowed_values:#{definition[:allowed_values]}" } }
-
-    context 'string validation' do
-      let(:definition) { {type: :string, allowed_values: ['a']} }
-      validate_valid_parameter('a')
-      validate_valid_parameter(['a'])
-      validate_invalid_parameter('b', ['b'])
-      validate_invalid_parameter(['b'], ['b'])
-    end
-
-    context 'string validation with default' do
-      let(:definition) { {type: :string, allowed_values: ['a'], default:'a'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'string validation with multiple' do
-      let(:definition) { {type: :string, allowed_values: ['a'], multiple: true} }
-      validate_valid_parameter('a,a')
-      validate_invalid_parameter( 'a,, a', [''])
-      validate_invalid_parameter( 'a,,b', ['', 'b'])
-    end
-
-    context 'string validation with multiple default values' do
-      let(:definition) { {type: :string, allowed_values: ['a'], multiple: true, default: 'a,a'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number, allowed_values: [1]} }
-      validate_valid_parameter(1)
-      validate_valid_parameter('1')
-      validate_valid_parameter([1])
-      validate_valid_parameter(['1'])
-      validate_invalid_parameter(2, [2])
-      validate_invalid_parameter('2', ['2'])
-    end
-
-    context 'numerical validation with default value' do
-      let(:definition) { {type: :number, allowed_values: [1], default: 1} }
-      validate_valid_parameter(nil)
-    end
-  end
-end

data/spec/stack_master/sparkle_formation/compile_time/definitions_validator_spec.rb

@@ -1,36 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::DefinitionsValidator do
-
-  describe '#validate' do
-
-    let(:key) {:key}
-    let(:definition){ {key: {type: type}} }
-
-    subject {described_class.new(definition)}
-
-    [:string, :number].each do |type|
-
-      context "with :#{type} type definition" do
-
-        let(:type) {type}
-
-        it 'should not raise an exception' do
-          expect {subject.validate}.to_not raise_error
-        end
-
-      end
-
-    end
-
-    context 'with other type definition' do
-
-      let(:type) {:other}
-
-      it 'should not raise an exception' do
-        expect {subject.validate}.to raise_error(ArgumentError, "Unknown compile time parameter type: #{key}:#{type} valid types are #{[:string, :number]}")
-      end
-
-    end
-
-  end
-
-end

data/spec/stack_master/sparkle_formation/compile_time/empty_validator_spec.rb

@@ -1,47 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::EmptyValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, _definition) { "#{name} cannot contain empty parameters:#{error.inspect}" } }
-
-    context 'string validation' do
-      let(:definition) { {type: :string} }
-      validate_valid_parameter('a')
-      validate_valid_parameter(['a'])
-      validate_invalid_parameter(nil, nil)
-      validate_invalid_parameter(['a', nil], ['a', nil])
-    end
-
-    context 'string validation with default' do
-      let(:definition) { {type: :string, default: 'a'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'string validation with multiples' do
-      let(:definition) { {type: :string, multiple: true} }
-      validate_valid_parameter('a,b')
-      validate_invalid_parameter('a,,b', 'a,,b')
-    end
-
-    context 'string validation with multiples and defaults' do
-      let(:definition) { {type: :string, multiple: true, default: 'a,b'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number} }
-      validate_valid_parameter(1)
-      validate_valid_parameter('1')
-      validate_valid_parameter([1])
-      validate_valid_parameter(['1'])
-      validate_invalid_parameter(nil, nil)
-      validate_invalid_parameter([1, nil], [1, nil])
-      validate_invalid_parameter(['1', nil], ['1', nil])
-    end
-
-    context 'numerical validation with default' do
-      let(:definition) { {type: :number, default: '1'} }
-      validate_valid_parameter(nil)
-    end
-  end
-end

data/spec/stack_master/sparkle_formation/compile_time/max_length_validator_spec.rb

@@ -1,37 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::MaxLengthValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, definition) { "#{name}:#{error} must not exceed max_length:#{definition[:max_length]} characters" } }
-
-    context 'string validation' do
-      let(:definition) { {type: :string, max_length: 1} }
-      validate_valid_parameter('a')
-      validate_valid_parameter(['a'])
-      validate_invalid_parameter('ab', ['ab'])
-      validate_invalid_parameter(['ab'], ['ab'])
-    end
-
-    context 'string validation with default value' do
-      let(:definition) { {type: :string, max_length: 1, default: 'a'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'string validation with multiples' do
-      let(:definition) { {type: :string, max_length: 1, multiple: true} }
-      validate_valid_parameter('a,a')
-      validate_valid_parameter('a,,a')
-      validate_invalid_parameter('a,, ab', ['ab'])
-    end
-
-    context 'string validation wtih multiples and default' do
-      let(:definition) { {type: :string, max_length: 1, multiple: true, default: 'a,a'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number, max_length: 1} }
-      validate_valid_parameter('ab')
-    end
-  end
-end

data/spec/stack_master/sparkle_formation/compile_time/max_size_validator_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::MaxSizeValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, definition) { "#{name}:#{error} must not be greater than max_size:#{definition[:max_size]}" } }
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number, max_size: 1} }
-      validate_valid_parameter(1)
-      validate_valid_parameter('1')
-      validate_valid_parameter([1])
-      validate_valid_parameter(['1'])
-      validate_invalid_parameter(2, [2])
-      validate_invalid_parameter('2', ['2'])
-    end
-
-    context 'numerical validation with default' do
-      let(:definition) { {type: :number, max_size: 1, default: 1} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'string validation' do
-      let(:definition) { {type: :string, max_size: 1} }
-      validate_valid_parameter(2)
-    end
-  end
-end

data/spec/stack_master/sparkle_formation/compile_time/min_length_validator_spec.rb

@@ -1,36 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::MinLengthValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, definition) { "#{name}:#{error} must be at least min_length:#{definition[:min_length]} characters" } }
-
-    context 'string validation' do
-      let(:definition) { {type: :string, min_length: 2} }
-      validate_valid_parameter('ab')
-      validate_valid_parameter(['ab'])
-      validate_invalid_parameter('a', ['a'])
-      validate_invalid_parameter(['a'], ['a'])
-    end
-
-    context 'string validation with default value' do
-      let(:definition) { {type: :string, min_length: 2, default: 'ab'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'string validation with multiples' do
-      let(:definition) { {type: :string, min_length: 2, multiple: true} }
-      validate_valid_parameter('ab,cd')
-      validate_invalid_parameter('a,, cd', ['a', ''])
-    end
-
-    context 'string validation with multiples and default' do
-      let(:definition) { {type: :string, min_length: 2, multiple: true, default: 'ab,cd'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number, min_length: 2} }
-      validate_valid_parameter('a')
-    end
-  end
-end

data/spec/stack_master/sparkle_formation/compile_time/min_size_validator_spec.rb

@@ -1,28 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::MinSizeValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, definition) { "#{name}:#{error} must not be lesser than min_size:#{definition[:min_size]}" } }
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number, min_size: 1} }
-      validate_valid_parameter(1)
-      validate_valid_parameter('1')
-      validate_valid_parameter([1])
-      validate_valid_parameter(['1'])
-      validate_invalid_parameter(0, [0])
-      validate_invalid_parameter('0', ['0'])
-    end
-
-    context 'numerical validation with default value' do
-      let(:definition) { {type: :number, min_size: 1, default: 1} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'string validation' do
-      let(:definition) { {type: :string, min_size: 1} }
-      validate_valid_parameter(0)
-    end
-
-  end
-end