stack_master 0.17.0 → 0.18.0

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

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

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

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

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

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

@@ -0,0 +1,40 @@
+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/stack_spec.rb

@@ -14,12 +14,12 @@ RSpec.describe StackMaster::Stack do
     context 'when the stack exists in AWS' do
       let(:parameters) {
         [
-          {parameter_key: 'param1', parameter_value: 'value1'},
-          {parameter_key: 'param2', parameter_value: 'value2'}
+            {parameter_key: 'param1', parameter_value: 'value1'},
+            {parameter_key: 'param2', parameter_value: 'value2'}
         ]
       }
       before do
-        cf.stub_responses(:describe_stacks, stacks: [{ stack_id: stack_id, stack_name: stack_name, creation_time: Time.now, stack_status: 'UPDATE_COMPLETE', parameters: parameters, notification_arns: ['test_arn'], role_arn: 'test_service_role_arn'}])
+        cf.stub_responses(:describe_stacks, stacks: [{stack_id: stack_id, stack_name: stack_name, creation_time: Time.now, stack_status: 'UPDATE_COMPLETE', parameters: parameters, notification_arns: ['test_arn'], role_arn: 'test_service_role_arn'}])
         cf.stub_responses(:get_template, template_body: "{}")
         cf.stub_responses(:get_stack_policy, stack_policy_body: stack_policy_body)
       end
@@ -39,7 +39,7 @@ RSpec.describe StackMaster::Stack do
       it 'sets role_arn' do
         expect(stack.role_arn).to eq('test_service_role_arn')
       end
-      
+
       it 'sets notification_arns' do
         expect(stack.notification_arns).to eq(['test_arn'])
       end
@@ -73,12 +73,13 @@ RSpec.describe StackMaster::Stack do
   end
 
   describe '.generate' do
-    let(:tags) { { 'tag1' => 'value1' } }
+    let(:tags) { {'tag1' => 'value1'} }
     let(:stack_definition) { StackMaster::StackDefinition.new(region: region, stack_name: stack_name, tags: tags, base_dir: '/base_dir', template: template_file_name, notification_arns: ['test_arn'], role_arn: 'test_service_role_arn', stack_policy_file: 'no_replace_rds.json') }
     let(:config) { StackMaster::Config.new({'stacks' => {}}, '/base_dir') }
     subject(:stack) { StackMaster::Stack.generate(stack_definition, config) }
-    let(:parameter_hash) { { 'DbPassword' => { 'secret' => 'db_password' } } }
-    let(:resolved_parameters) { { 'DbPassword' => 'sdfgjkdhlfjkghdflkjghdflkjg', 'InstanceType' => 't2.medium' } }
+    let(:parameter_hash) { {template_parameters: {'DbPassword' => {'secret' => 'db_password'}}, compile_time_parameters: {}} }
+    let(:resolved_template_parameters) { {'DbPassword' => 'sdfgjkdhlfjkghdflkjghdflkjg', 'InstanceType' => 't2.medium'} }
+    let(:resolved_compile_time_parameters) { {} }
     let(:template_file_name) { 'template.rb' }
     let(:template_body) { '{"Parameters": { "VpcId": { "Description": "VPC ID" }, "InstanceType": { "Description": "Instance Type", "Default": "t2.micro" }} }' }
     let(:template_format) { :json }
@@ -86,8 +87,9 @@ RSpec.describe StackMaster::Stack do
 
     before do
       allow(StackMaster::ParameterLoader).to receive(:load).and_return(parameter_hash)
-      allow(StackMaster::ParameterResolver).to receive(:resolve).and_return(resolved_parameters)
-      allow(StackMaster::TemplateCompiler).to receive(:compile).with(config, stack_definition.template_file_path, stack_definition.compiler_options).and_return(template_body)
+      allow(StackMaster::ParameterResolver).to receive(:resolve).with(config,stack_definition,parameter_hash[:template_parameters]).and_return(resolved_template_parameters)
+      allow(StackMaster::ParameterResolver).to receive(:resolve).with(config,stack_definition,parameter_hash[:compile_time_parameters]).and_return(resolved_compile_time_parameters)
+      allow(StackMaster::TemplateCompiler).to receive(:compile).with(config, stack_definition.template_file_path, resolved_compile_time_parameters, stack_definition.compiler_options).and_return(template_body)
       allow(File).to receive(:read).with(stack_definition.stack_policy_file_path).and_return(stack_policy_body)
     end
 
@@ -104,7 +106,7 @@ RSpec.describe StackMaster::Stack do
     end
 
     it 'resolves the parameters' do
-      expect(stack.parameters).to eq resolved_parameters
+      expect(stack.parameters).to eq resolved_template_parameters
     end
 
     it 'compiles the template body' do
@@ -114,7 +116,7 @@ RSpec.describe StackMaster::Stack do
     it 'has role_arn' do
       expect(stack.role_arn).to eq 'test_service_role_arn'
     end
-    
+
     it 'has notification_arns' do
       expect(stack.notification_arns).to eq ['test_arn']
     end
@@ -168,13 +170,13 @@ RSpec.describe StackMaster::Stack do
     let(:stack) { StackMaster::Stack.new(parameters: parameters, template_body: '{}', template_format: :json) }
 
     context 'when a parameter has a nil value' do
-      let(:parameters) { { 'my_param' => nil } }
+      let(:parameters) { {'my_param' => nil} }
 
       it { should eq true }
     end
 
     context 'when no parameers have a nil value' do
-      let(:parameters) { { 'my_param' => '1' } }
+      let(:parameters) { {'my_param' => '1'} }
 
       it { should eq false }
     end

data/spec/stack_master/template_compiler_spec.rb

@@ -2,10 +2,11 @@ RSpec.describe StackMaster::TemplateCompiler do
   describe '.compile' do
     let(:config) { double(template_compilers: { fab: :test_template_compiler }) }
     let(:template_file_path) { '/base_dir/templates/template.fab' }
+    let(:compile_time_parameters) { { 'InstanceType' => 't2.medium' } }
 
     class TestTemplateCompiler
       def self.require_dependencies; end
-      def self.compile(template_file_path, compile_options); end
+      def self.compile(template_file_path, compile_time_parameters, compile_options); end
     end
 
     context 'when a template compiler is registered for the given file type' do
@@ -14,21 +15,21 @@ RSpec.describe StackMaster::TemplateCompiler do
       }
 
       it 'compiles the template using the relevant template compiler' do
-        expect(TestTemplateCompiler).to receive(:compile).with(template_file_path, anything)
-        StackMaster::TemplateCompiler.compile(config, template_file_path)
+        expect(TestTemplateCompiler).to receive(:compile).with(template_file_path, compile_time_parameters, anything)
+        StackMaster::TemplateCompiler.compile(config, template_file_path, compile_time_parameters, compile_time_parameters)
       end
 
       it 'passes compile_options to the template compiler' do
         opts = {foo: 1, bar: true, baz: "meh"}
-        expect(TestTemplateCompiler).to receive(:compile).with(template_file_path, opts)
-        StackMaster::TemplateCompiler.compile(config, template_file_path, opts)
+        expect(TestTemplateCompiler).to receive(:compile).with(template_file_path, compile_time_parameters, opts)
+        StackMaster::TemplateCompiler.compile(config, template_file_path, compile_time_parameters,opts)
       end
 
       context 'when template compilation fails' do
         before { allow(TestTemplateCompiler).to receive(:compile).and_raise(RuntimeError) }
 
         it 'raise TemplateCompilationFailed exception' do
-          expect{ StackMaster::TemplateCompiler.compile(config, template_file_path)
+          expect{ StackMaster::TemplateCompiler.compile(config, template_file_path, compile_time_parameters, compile_time_parameters)
           }.to raise_error(
                  StackMaster::TemplateCompiler::TemplateCompilationFailed,"Failed to compile #{template_file_path}.")
         end

data/spec/stack_master/template_compilers/cfndsl_spec.rb

@@ -1,9 +1,12 @@
 RSpec.describe StackMaster::TemplateCompilers::Cfndsl do
+
+  let(:compile_time_parameters) { {'InstanceType' => 't2.medium'} }
+
   before(:all) { described_class.require_dependencies }
 
   describe '.compile' do
     def compile
-      described_class.compile(template_file_path)
+      described_class.compile(template_file_path, compile_time_parameters)
     end
 
     context 'valid cfndsl template' do

data/spec/stack_master/template_compilers/json_spec.rb

@@ -1,7 +1,10 @@
 RSpec.describe StackMaster::TemplateCompilers::Json do
+
+  let(:compile_time_parameters) { { 'InstanceType' => 't2.medium' } }
+
   describe '.compile' do
     def compile
-      described_class.compile(template_file_path)
+      described_class.compile(template_file_path, compile_time_parameters)
     end
 
     let(:template_file_path) { '/base_dir/templates/template.json' }

data/spec/stack_master/template_compilers/sparkle_formation_spec.rb

@@ -1,15 +1,34 @@
 RSpec.describe StackMaster::TemplateCompilers::SparkleFormation do
+
   describe '.compile' do
     def compile
-      described_class.compile(template_file_path, compiler_options)
-    end
-
-    before do
-      allow(SparkleFormation).to receive(:compile).with(template_file_path).and_return({})
+      described_class.compile(template_file_path, compile_time_parameters, compiler_options)
     end
 
     let(:template_file_path) { '/base_dir/templates/template.rb' }
+    let(:compile_time_parameters) { {'Ip' => '10.0.0.0', 'Name' => 'Something'} }
     let(:compiler_options) { {} }
+    let(:compile_time_parameter_definitions) { {} }
+
+    let(:sparkle_template) { instance_double(::SparkleFormation) }
+    let(:definitions_validator) { instance_double(StackMaster::SparkleFormation::CompileTime::DefinitionsValidator) }
+    let(:parameters_validator) { instance_double(StackMaster::SparkleFormation::CompileTime::ParametersValidator) }
+    let(:state_builder) { instance_double(StackMaster::SparkleFormation::CompileTime::StateBuilder) }
+
+    before do
+      allow(::SparkleFormation).to receive(:compile).with(template_file_path, :sparkle).and_return(sparkle_template)
+      allow(StackMaster::SparkleFormation::CompileTime::DefinitionsValidator).to receive(:new).and_return(definitions_validator)
+      allow(StackMaster::SparkleFormation::CompileTime::ParametersValidator).to receive(:new).and_return(parameters_validator)
+      allow(StackMaster::SparkleFormation::CompileTime::StateBuilder).to receive(:new).and_return(state_builder)
+
+      allow(sparkle_template).to receive(:parameters).and_return(compile_time_parameter_definitions)
+      allow(definitions_validator).to receive(:validate)
+      allow(parameters_validator).to receive(:validate)
+      allow(state_builder).to receive(:build).and_return({})
+      allow(sparkle_template).to receive(:compile_time_parameter_setter).and_yield
+      allow(sparkle_template).to receive(:compile_state=)
+      allow(sparkle_template).to receive(:to_json).and_return("{\n}")
+    end
 
     it 'compiles with sparkleformation' do
       expect(compile).to eq("{\n}")
@@ -17,21 +36,46 @@ RSpec.describe StackMaster::TemplateCompilers::SparkleFormation do
 
     it 'sets the appropriate sparkle_path' do
       compile
-      expect(SparkleFormation.sparkle_path).to eq File.dirname(template_file_path)
+      expect(::SparkleFormation.sparkle_path).to eq File.dirname(template_file_path)
+    end
+
+    it 'should validate the compile time definitions' do
+      expect(StackMaster::SparkleFormation::CompileTime::DefinitionsValidator).to receive(:new).with(compile_time_parameter_definitions)
+      expect(definitions_validator).to receive(:validate)
+      compile
+    end
+
+    it 'should validate the parameters against any compile time definitions' do
+      expect(StackMaster::SparkleFormation::CompileTime::ParametersValidator).to receive(:new).with(compile_time_parameter_definitions, compile_time_parameters)
+      expect(parameters_validator).to receive(:validate)
+      compile
+    end
+
+    it 'should create the compile state' do
+      expect(StackMaster::SparkleFormation::CompileTime::StateBuilder).to receive(:new).with(compile_time_parameter_definitions, compile_time_parameters)
+      expect(state_builder).to receive(:build)
+      compile
+    end
+
+    it 'should set the compile state' do
+      expect(sparkle_template).to receive(:compile_state=).with({})
+      compile
     end
 
     context 'with a custom sparkle_path' do
-      let(:compiler_options)  { { "sparkle_path" => '../foo' } }
+      let(:compiler_options) { {'sparkle_path' => '../foo'} }
 
       it 'does not use the default path' do
         compile
-        expect(SparkleFormation.sparkle_path).to_not eq File.dirname(template_file_path)
+        expect(::SparkleFormation.sparkle_path).to_not eq File.dirname(template_file_path)
       end
 
       it 'expands the given path' do
         compile
-        expect(SparkleFormation.sparkle_path).to match %r{^/.+/foo}
+        expect(::SparkleFormation.sparkle_path).to match %r{^/.+/foo}
       end
     end
+
   end
+
 end