stack_master 0.17.0 → 0.18.0

data/spec/stack_master/parameter_loader_spec.rb

@@ -1,81 +1,93 @@
 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
+  let(:stack_file_name) { '/base_dir/parameters/stack_name.yml' }
+  let(:region_file_name) { '/base_dir/parameters/us-east-1/stack_name.yml' }
 
-    it "returns empty parameters" do
-      expect(parameters).to eq({})
-    end
+  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 "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
+  context 'no parameter file' do
+    let(:stack_file_returns) { {exists: false} }
+    let(:region_file_returns) { {exists: false} }
 
-    it "returns an empty hash" do
-      expect(parameters).to eq({})
+    it 'returns empty parameters' do
+      expect(parameters).to eq(template_parameters: {}, compile_time_parameters: {})
     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")
+  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({ 'Param1' => 'value1' })
+    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
-    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")
+  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
 
-    it "returns params from the region base stack_name.yml" do
-      expect(parameters).to eq({ 'Param2' => 'value2' })
+  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 "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")
+  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
 
-    it "returns params from the region base stack_name.yml" do
-      expect(parameters).to eq({
-                                                  'Param1' => 'value1',
-                                                  'Param2' => 'value2'
-                                                })
+    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
-    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
+    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({'VpcId' => 'vpc-xxxxxx'})
+    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/sparkle_formation/compile_time/allowed_pattern_validator_spec.rb

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

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

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

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

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

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

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

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