stack_master 1.5.0 → 1.6.0

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

@@ -1,41 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::NumberValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, _definition) { "#{name}:#{error} are not Numbers" } }
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number} }
-      validate_valid_parameter(1)
-      validate_valid_parameter(['1'])
-      validate_invalid_parameter(['1.'], ['1.'])
-      validate_invalid_parameter(['.1'], ['.1'])
-      validate_invalid_parameter(['1.1.1'], ['1.1.1'])
-      validate_invalid_parameter(['1a1'], ['1a1'])
-    end
-
-    context 'numerical validation with default' do
-      let(:definition) { {type: :number, default: 1} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'numerical validation with multiples' do
-      let(:definition) { {type: :number, multiple: true} }
-      validate_valid_parameter('1,2')
-      validate_valid_parameter([1, 2])
-      validate_invalid_parameter('1,1.', ['1.'])
-      validate_invalid_parameter({}, [{}])
-    end
-
-    context 'numerical validation with multiples and default' do
-      let(:definition) { {type: :number, multiple: true, default: '1,2'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'string validation' do
-      let(:definition) { {type: :string} }
-      validate_valid_parameter('a')
-    end
-
-  end
-end

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

@@ -1,65 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::ParametersValidator do
-
-  let(:definitions) {{ip: {type: :string}}}
-  let(:parameters) {{'Ip' => '10.0.0.0'}}
-  let(:value_validator_factory) {instance_double(StackMaster::SparkleFormation::CompileTime::ValueValidatorFactory)}
-  let(:value_validator) {instance_double(StackMaster::SparkleFormation::CompileTime::ValueValidator)}
-
-  subject {described_class.new(definitions, parameters)}
-
-  before(:each) do
-    allow(StackMaster::SparkleFormation::CompileTime::ValueValidatorFactory)
-        .to receive(:new).and_return(value_validator_factory)
-    allow(value_validator_factory)
-        .to receive(:build).and_return([value_validator])
-    allow(value_validator).to receive(:validate)
-    allow(value_validator).to receive(:is_valid).and_return(true)
-  end
-
-  describe '#validate' do
-
-    it('should initialise the ValueValidatorFactory') do
-      expect(StackMaster::SparkleFormation::CompileTime::ValueValidatorFactory).to receive(:new).with(:ip, {type: :string}, '10.0.0.0')
-      subject.validate
-    end
-
-    it('should build validators') do
-      expect(value_validator_factory).to receive(:build)
-      subject.validate
-    end
-
-    it('should call validate on all validators') do
-      expect(value_validator).to receive(:validate)
-      subject.validate
-    end
-
-    context 'when the validators are valid' do
-
-      before(:each) do
-        allow(value_validator).to receive(:is_valid).and_return(true)
-      end
-
-      it('should not raise any error') do
-        expect{subject.validate}.to_not raise_error
-      end
-
-    end
-
-    context 'when the validators are invalid' do
-
-      let(:error){'error'}
-
-      before(:each) do
-        allow(value_validator).to receive(:is_valid).and_return(false)
-        allow(value_validator).to receive(:error).and_return(error)
-      end
-
-      it('should raise an error') do
-        expect {subject.validate}.to raise_error(ArgumentError, "Invalid compile time parameter: #{error}")
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,28 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::StateBuilder do
-
-  let(:definitions) {{ip: {type: :string}, size: {type: :number}}}
-  let(:ip) {'10.0.0.0'}
-  let(:size) {nil}
-  let(:parameters) {{'Ip' => ip}}
-  let(:ip_builder) {instance_double(StackMaster::SparkleFormation::CompileTime::ValueBuilder)}
-  let(:size_builder) {instance_double(StackMaster::SparkleFormation::CompileTime::ValueBuilder)}
-
-  subject {described_class.new(definitions, parameters)}
-
-  before(:each) do
-    allow(StackMaster::SparkleFormation::CompileTime::ValueBuilder).to receive(:new).with({type: :string}, ip).and_return(ip_builder)
-    allow(StackMaster::SparkleFormation::CompileTime::ValueBuilder).to receive(:new).with({type: :number}, size).and_return(size_builder)
-    allow(ip_builder).to receive(:build).and_return(ip)
-    allow(size_builder).to receive(:build).and_return(size)
-  end
-
-  describe '#build' do
-
-    it 'should create state' do
-      expected = {ip: '10.0.0.0', size: nil}
-      expect(subject.build).to eq(expected)
-    end
-
-  end
-
-end

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

@@ -1,35 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::StringValidator do
-
-  describe '#validate' do
-    let(:name) { 'name' }
-    let(:error_message) { -> (error, _definition) { "#{name}:#{error} are not Strings" } }
-
-    context 'string validation' do
-      let(:definition) { {type: :string} }
-      validate_valid_parameter('a')
-      validate_valid_parameter([''])
-      validate_invalid_parameter({}, [{}])
-    end
-
-    context 'string validation 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([{}], [{}])
-    end
-
-    context 'string validation with multiples and default' do
-      let(:definition) { {type: :string, multiple: true, default: 'a,a'} }
-      validate_valid_parameter(nil)
-    end
-
-    context 'numerical validation' do
-      let(:definition) { {type: :number} }
-      validate_valid_parameter(1)
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::ValueBuilder do
-  scenarios= [
-      {definition: {type: :string}, parameter: nil, expected: nil},
-      {definition: {type: :string}, parameter: 'a', expected: 'a'},
-      {definition: {type: :string}, parameter: ['a'], expected: ['a']},
-
-      {definition: {type: :string, default: 'a'}, parameter: nil, expected: 'a'},
-
-      {definition: {type: :string, multiple: true}, parameter: 'a', expected: ['a']},
-      {definition: {type: :string, multiple: true}, parameter: 'a,b', expected: ['a', 'b']},
-      {definition: {type: :string, multiple: true}, parameter: 'a, b', expected: ['a', 'b']},
-
-      {definition: {type: :string, multiple: true, default: 'a'}, parameter: nil, expected: ['a']},
-
-      {definition: {type: :number}, parameter: nil, expected: nil},
-      {definition: {type: :number}, parameter: 1, expected: 1},
-      {definition: {type: :number}, parameter: '1', expected: 1},
-      {definition: {type: :number}, parameter: [1], expected: [1]},
-      {definition: {type: :number}, parameter: ['1'], expected: [1]},
-
-      {definition: {type: :number, default: '1'}, parameter: nil, expected: 1},
-
-      {definition: {type: :number, multiple: true}, parameter: 1, expected: 1},
-      {definition: {type: :number, multiple: true}, parameter: '1', expected: [1]},
-      {definition: {type: :number, multiple: true}, parameter: '1,2', expected: [1,2]},
-      {definition: {type: :number, multiple: true}, parameter: '1, 2', expected: [1,2]},
-
-      {definition: {type: :number, multiple: true, default: '1'}, parameter: nil, expected: [1]}
-  ]
-
-  describe '#build' do
-
-    scenarios.each do |scenario|
-
-      description = scenario.clone.tap {|clone| clone.delete(:expected)}
-      context "when #{description}" do
-
-        definition = scenario[:definition]
-        parameter = scenario[:parameter]
-        expected = scenario[:expected]
-
-        it("should have a value of #{expected}") do
-          expect(described_class.new(definition, parameter).build).to eq expected
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,40 +0,0 @@
-RSpec.describe StackMaster::SparkleFormation::CompileTime::ValueValidatorFactory do
-
-  let(:name) {:ip}
-  let(:definition) {{type: :string}}
-  let(:parameter) {{'Ip' => '10.0.0.0'}}
-
-  subject {described_class.new(name, definition, parameter)}
-
-  describe '#build' do
-
-    validators = [
-        StackMaster::SparkleFormation::CompileTime::EmptyValidator,
-        StackMaster::SparkleFormation::CompileTime::StringValidator,
-        StackMaster::SparkleFormation::CompileTime::NumberValidator,
-        StackMaster::SparkleFormation::CompileTime::AllowedValuesValidator,
-        StackMaster::SparkleFormation::CompileTime::AllowedPatternValidator,
-        StackMaster::SparkleFormation::CompileTime::MaxLengthValidator,
-        StackMaster::SparkleFormation::CompileTime::MinLengthValidator,
-        StackMaster::SparkleFormation::CompileTime::MaxSizeValidator,
-        StackMaster::SparkleFormation::CompileTime::MinSizeValidator]
-
-    after(:each){subject.build}
-
-    validators.each do |validator|
-
-      it "should build a #{validator} with correct parameters" do
-        expect(validator).to receive(:new).with(name, definition, parameter)
-      end
-
-    end
-
-    it 'should build in the correct order' do
-      validators.each do |validator|
-        expect(validator).to receive(:new).ordered
-      end
-    end
-
-  end
-
-end

data/spec/stack_master/sparkle_formation/template_file_spec.rb

@@ -1,147 +0,0 @@
-require 'stack_master/sparkle_formation/template_file'
-
-RSpec.describe SparkleFormation::SparkleAttribute::Aws, '#user_data_file!' do
-  let(:user_data) do
-    <<-EOS
-#!/bin/bash
-
-REGION=<%= region! %>
-echo $REGION
-<%= ref!(:test) %> <%= ref!(:test_2) %>
-<%= has_var?(:test) ? "echo 'yes'" : "echo 'no'" %>
-    EOS
-  end
-  let(:expected_hash) do
-    {"Fn::Base64"=>{"Fn::Join"=>["", ["#!/bin/bash\n", "\n", "REGION=", {"Ref"=>"AWS::Region"}, "\n", "echo $REGION\n", {"Ref"=>"Test"}, " ", {"Ref"=>"Test2"}, "\n", "echo 'no'", "\n"]]}}
-  end
-
-  before do
-    allow(SparkleFormation).to receive(:sparkle_path).and_return('/templates_dir')
-    klass = Class.new(AttributeStruct)
-    klass.include(SparkleFormation::SparkleAttribute)
-    klass.include(SparkleFormation::SparkleAttribute::Aws)
-    klass.include(SparkleFormation::Utils::TypeCheckers)
-    @attr = klass.new
-    @attr._camel_keys = true
-  end
-
-  it 'reads from the user_data dir in templates' do
-    expect(File).to receive(:read).with('/templates_dir/user_data/test.erb').and_return(user_data)
-    @attr.user_data_file!('test.erb')
-  end
-
-  context 'when the file exists' do
-    before do
-      allow(File).to receive(:read).and_return(user_data)
-    end
-
-    it 'compiles the file and returns a joined version' do
-      expect(@attr.user_data_file!('test.erb')).to eq expected_hash
-    end
-
-    context 'with custom vars' do
-      let(:user_data) do
-        <<-EOS
-#!/bin/bash
-<%= my_custom_var %>
-<%= has_var?(:my_custom_var) ? "yes" : "no" %>
-        EOS
-      end
-      let(:expected_hash) do
-        {"Fn::Base64"=>{"Fn::Join"=>["", ["#!/bin/bash\n", "test_var", "\n", "yes", "\n"]]}}
-      end
-
-      it 'compiles the file and returns a joined version' do
-        expect(@attr.user_data_file!('test.erb', my_custom_var: :test_var)).to eq expected_hash
-        expect(@attr.user_data_file!('test.erb', my_custom_var: 'test_var')).to eq expected_hash
-      end
-    end
-  end
-
-  context "when the file doesn't exist" do
-    before do
-      allow(File).to receive(:read).and_raise(Errno::ENOENT)
-    end
-
-    it 'raises a specific error' do
-      expect {
-        @attr.user_data_file!('test.erb')
-      }.to raise_error(StackMaster::SparkleFormation::TemplateFileNotFound)
-    end
-  end
-
-  context 'with nested templates' do
-    let(:inner_user_data) do
-      <<-EOS
-REGION=<%= region! %>
-<%= test1 %>
-<%= has_var?(:test2) ? 'yes' : 'no' %>
-      EOS
-    end
-
-    let(:outer_user_data) do
-      <<-EOS
-#!/bin/bash
-<%= test1 %> <%= test2 %>
-<%= render 'inner.sh.erb', test1: 'inner1' %>
-      EOS
-    end
-
-    let(:expected_hash) do
-      {"Fn::Base64"=>{"Fn::Join"=>["", [
-        "#!/bin/bash\n",
-        "outer1", " ", "outer2", "\n",
-        "REGION=", {"Ref"=>"AWS::Region"}, "\n",
-        "inner1", "\n",
-        "no", "\n", "\n"
-      ]]}}
-    end
-
-    before do
-      allow(File).to receive(:read).and_call_original
-      allow(File).to receive(:read).with('/templates_dir/user_data/outer.sh.erb').and_return(outer_user_data)
-      allow(File).to receive(:read).with('/templates_dir/user_data/inner.sh.erb').and_return(inner_user_data)
-    end
-
-    it 'renders the outer template, including the inner template with its own var context' do
-      expect(@attr.user_data_file!('outer.sh.erb', test1: :outer1, test2: 'outer2')).to eq expected_hash
-    end
-  end
-end
-
-RSpec.describe SparkleFormation::SparkleAttribute::Aws, '#joined_file!' do
-  let(:config) do
-    <<-EOS
-variable=<%= ref!(:test) %>
-    EOS
-  end
-
-  let(:expected_hash) do
-    {"Fn::Join"=>["", ["variable=", {"Ref"=>"Test"}, "\n"]]}
-  end
-
-  before do
-    allow(SparkleFormation).to receive(:sparkle_path).and_return('/templates_dir')
-    klass = Class.new(AttributeStruct)
-    klass.include(SparkleFormation::SparkleAttribute)
-    klass.include(SparkleFormation::SparkleAttribute::Aws)
-    klass.include(SparkleFormation::Utils::TypeCheckers)
-    @attr = klass.new
-    @attr._camel_keys = true
-  end
-
-  it 'reads from the config dir in templates' do
-    expect(File).to receive(:read).with('/templates_dir/joined_file/test.erb').and_return(config)
-    @attr.joined_file!('test.erb')
-  end
-
-  context 'when the file exists' do
-    before do
-      allow(File).to receive(:read).and_return(config)
-    end
-
-    it 'compiles the file and returns a joined version' do
-      expect(@attr.joined_file!('test.erb')).to eq expected_hash
-    end
-  end
-end

data/spec/stack_master/stack_definition_spec.rb

@@ -1,70 +0,0 @@
-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' }
-
-  before do
-    allow(Dir).to receive(:glob).with(
-      File.join(base_dir, 'parameters', "#{stack_name}.y*ml")
-    ).and_return(
-      [
-        "/base_dir/parameters/#{stack_name}.yaml",
-        "/base_dir/parameters/#{stack_name}.yml",
-      ]
-    )
-
-    allow(Dir).to receive(:glob).with(
-      File.join(base_dir, 'parameters', "#{region}", "#{stack_name}.y*ml")
-    ).and_return(
-      [
-        "/base_dir/parameters/#{region}/#{stack_name}.yaml",
-        "/base_dir/parameters/#{region}/#{stack_name}.yml",
-      ]
-    )
-  end
-
-  it 'has default and region specific parameter file locations' do
-    expect(stack_definition.parameter_files).to eq([
-      "/base_dir/parameters/#{stack_name}.yaml",
-      "/base_dir/parameters/#{stack_name}.yml",
-      "/base_dir/parameters/#{region}/#{stack_name}.yaml",
-      "/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'])
-      allow(Dir).to receive(:glob).with(
-        File.join(base_dir, 'parameters', "production", "#{stack_name}.y*ml")
-      ).and_return(
-        [
-          "/base_dir/parameters/production/#{stack_name}.yaml",
-          "/base_dir/parameters/production/#{stack_name}.yml",
-        ]
-      )
-    end
-
-    it 'includes a parameter lookup dir for it' do
-      expect(stack_definition.parameter_files).to eq([
-        "/base_dir/parameters/#{stack_name}.yaml",
-        "/base_dir/parameters/#{stack_name}.yml",
-        "/base_dir/parameters/#{region}/#{stack_name}.yaml",
-        "/base_dir/parameters/#{region}/#{stack_name}.yml",
-        "/base_dir/parameters/production/#{stack_name}.yaml",
-        "/base_dir/parameters/production/#{stack_name}.yml",
-      ])
-    end
-  end
-end