cloud-templates 0.1.0

data/spec/aws/templates/utils/parametrized/transformation_spec.rb

@@ -0,0 +1,314 @@
+require 'spec_helper'
+require 'aws/templates/utils/parametrized'
+require 'aws/templates/utils/parametrized/transformations'
+require 'aws/templates/utils/parametrized/constraints'
+require 'aws/templates/utils/parametrized/getters'
+require 'aws/templates/render'
+
+module TestRender
+  extend Aws::Templates::Render
+  StringView = Class.new(Aws::Templates::Render::BasicView) do
+    def to_rendered
+      _stringify(instance)
+    end
+
+    def _stringify(obj)
+      return obj.to_s unless obj.respond_to?(:to_hash)
+      obj.to_hash.map { |k, v| [_stringify(k), _stringify(v)] }.to_h
+    end
+  end
+  StringView.register_in self
+  StringView.artifact ::Object
+end
+
+describe Aws::Templates::Utils::Parametrized::Transformation do
+  let(:parametrized_class) do
+    Class.new do
+      include Aws::Templates::Utils::Parametrized
+
+      def self.getter
+        as_is
+      end
+
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+    end
+  end
+
+  describe 'as_object' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something,
+                  transform: as_object {
+                    parameter :a, description: 'Parameter A'
+                    parameter :b, description: 'Parameter B'
+                    parameter :c, description: 'Parameter C', constraint: not_nil
+                  }
+      end
+    end
+
+    it 'transforms hash into object correctly' do
+      i = test_class.new(something: { a: 1, b: 2, c: 3 })
+      expect([i.something.a, i.something.b, i.something.c])
+        .to be == [1, 2, 3]
+    end
+
+    it 'allows nil values in sub-fields if no constraint is specified' do
+      i = test_class.new(something: { a: 1, b: nil, c: 3 })
+      expect([i.something.a, i.something.b, i.something.c])
+        .to be == [1, nil, 3]
+    end
+
+    it 'throws an error if sub-parameter constraint is not satisfied' do
+      i = test_class.new(something: { a: 1, b: 2, c: nil })
+      expect { [i.something.a, i.something.b, i.something.c] }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+  end
+
+  describe 'as_list' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something,
+                  description: 'Something misterious',
+                  transform: as_list(
+                    name: :element,
+                    description: 'Force of nature'
+                  )
+        parameter :something_else,
+                  description: 'Absolutely incomprehensible',
+                  transform: as_list(
+                    name: :element,
+                    description: 'Celestial image',
+                    constraint: not_nil
+                  )
+      end
+    end
+
+    it 'handles nil values' do
+      expect(test_class.new({}).something).to be_nil
+    end
+
+    it 'handles list value' do
+      expect(test_class.new(something: [1, 2, 3]).something).to be == [1, 2, 3]
+    end
+
+    it 'allows nil values if no constraints are specified' do
+      expect(test_class.new(something: [1, nil, 3]).something).to be == [1, nil, 3]
+    end
+
+    it 'works with any kind of object' do
+      expect(test_class.new(something: 'abc'.each_char).something).to be == %w[a b c]
+    end
+
+    it 'fails if the value can be transformed to an array' do
+      expect { test_class.new(something: 'abc').something }
+        .to raise_error Aws::Templates::NestedParameterException
+    end
+
+    it 'returns correct value if sub-constraints are satisfied' do
+      expect(test_class.new(something_else: [1, 2, 3]).something_else).to be == [1, 2, 3]
+    end
+
+    it 'throws an exception if one or more elements don\'t satisfy sub-constraint' do
+      expect { test_class.new(something_else: [1, nil, 3]).something_else }
+        .to raise_error(/Celestial image/)
+    end
+  end
+
+  describe 'as_rendered' do
+    let(:render) { TestRender }
+
+    let(:test_class) do
+      klass = Class.new(parametrized_class)
+      klass.parameter :something, transform: klass.as_rendered(render)
+      klass
+    end
+
+    it 'transforms hash into stringified hash correctly' do
+      i = test_class.new(something: { a: 1, b: 2, c: 3 })
+      expect(i.something).to be == { 'a' => '1', 'b' => '2', 'c' => '3' }
+    end
+
+    it 'allows nil value' do
+      i = test_class.new({})
+      expect(i.something).to be_nil
+    end
+  end
+
+  describe 'as_integer' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something, transform: as_integer
+      end
+    end
+
+    it 'transforms string into integer correctly' do
+      i = test_class.new(something: '23')
+      expect(i.something).to be == 23
+    end
+
+    it 'allows nil value' do
+      i = test_class.new({})
+      expect(i.something).to be_nil
+    end
+
+    it 'fails on wrong value' do
+      i = test_class.new(something: [])
+      expect { i.something }.to raise_error Aws::Templates::NestedParameterException
+    end
+  end
+
+  describe 'as_string' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something, transform: as_string
+      end
+    end
+
+    it 'transforms integer into string correctly' do
+      i = test_class.new(something: 23)
+      expect(i.something).to be == '23'
+    end
+
+    it 'allows nil value' do
+      i = test_class.new({})
+      expect(i.something).to be_nil
+    end
+  end
+
+  describe 'as_boolean' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something, transform: as_boolean
+      end
+    end
+
+    it 'transforms string into boolean correctly' do
+      i = test_class.new(something: 23)
+      expect(i.something).to be == true
+    end
+
+    it 'transforms false correctly' do
+      i = test_class.new(something: false)
+      expect(i.something).to be == false
+    end
+
+    it 'transforms true correctly' do
+      i = test_class.new(something: true)
+      expect(i.something).to be == true
+    end
+
+    it 'transforms false string correctly' do
+      i = test_class.new(something: 'false')
+      expect(i.something).to be == false
+    end
+
+    it 'allows nil value' do
+      i = test_class.new({})
+      expect(i.something).to be_nil
+    end
+  end
+
+  describe 'as_hash' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something, transform: as_hash
+        parameter :something2,
+                  transform: as_hash {
+                    key name: :key,
+                        description: 'String key',
+                        constraint: not_nil,
+                        transform: as_string
+                    value name: :number,
+                          description: 'Just a number',
+                          constraint: not_nil,
+                          transform: as_integer
+                  }
+      end
+    end
+
+    let(:hashable) do
+      Class.new do
+        def to_hash
+          { w: 'qwe' }
+        end
+      end
+    end
+
+    it 'transforms hash correctly' do
+      i = test_class.new(something: { q: 3 })
+      expect(i.something).to be == { q: 3 }
+    end
+
+    it 'transforms array into hash correctly' do
+      i = test_class.new(something: [[:q, 3]])
+      expect(i.something).to be == { q: 3 }
+    end
+
+    it 'transforms an object into hash correctly' do
+      i = test_class.new(something: hashable.new)
+      expect(i.something).to be == { w: 'qwe' }
+    end
+
+    it 'allows nil value' do
+      i = test_class.new({})
+      expect(i.something).to be_nil
+    end
+
+    it 'understands internal structure' do
+      i = test_class.new(something2: { q: '3' })
+      expect(i.something2).to be == { 'q' => 3 }
+    end
+
+    it 'performs internal constraint check' do
+      i = test_class.new(something2: { q: nil })
+      expect { i.something2 }.to raise_error(/Just a number/)
+    end
+  end
+
+  describe 'as_module' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something, transform: as_module
+      end
+    end
+
+    it 'passes a class as is' do
+      i = test_class.new(something: Object)
+      expect(i.something).to be == Object
+    end
+
+    it 'looks up class name' do
+      i = test_class.new(something: 'Object')
+      expect(i.something).to be == Object
+    end
+
+    it 'is able to work with paths' do
+      i = test_class.new(something: 'Object::Object::Object::Array')
+      expect(i.something).to be == Array
+    end
+
+    it 'accepts different path specifications' do
+      i = test_class.new(something: 'Object/Object/Object/Array')
+      expect(i.something).to be == Array
+    end
+  end
+
+  describe 'as_chain' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something,
+                  transform: as_chain(as_hash, as_object { parameter :rule })
+      end
+    end
+
+    it 'applies all transformations' do
+      i = test_class.new(something: [[:rule, 1]])
+      expect(i.something.rule).to be == 1
+    end
+  end
+end

data/spec/aws/templates/utils/parametrized_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+require 'aws/templates/utils/parametrized'
+require 'aws/templates/utils/parametrized/getters'
+
+describe Aws::Templates::Utils::Parametrized do
+  let(:including_class) do
+    Class.new do
+      include Aws::Templates::Utils::Parametrized
+
+      attr_reader :options
+
+      def self.getter
+        as_is
+      end
+
+      def initialize(options)
+        @options = options
+      end
+    end
+  end
+
+  let(:including_module) do
+    Module.new do
+      include Aws::Templates::Utils::Parametrized
+
+      parameter :mixed_parameter,
+                description: 'Just a parameter which will be added ' \
+                  'into including modules/classes',
+                transform: ->(_, v) { v.to_s }
+    end
+  end
+
+  describe 'module include' do
+    it 'has parameter DSL method' do
+      expect(including_module).to respond_to(:parameter)
+    end
+
+    it 'has accessor defined with the DSL' do
+      expect(including_module.method_defined?(:mixed_parameter))
+        .to be == true
+    end
+
+    it 'has parameter object defined with appropriate name' do
+      expect(including_module.get_parameter(:mixed_parameter).name)
+        .to be == :mixed_parameter
+    end
+  end
+
+  describe 'class include' do
+    it 'has parameter DSL method' do
+      expect(including_class).to respond_to(:parameter)
+    end
+  end
+
+  context 'Class is inherited and the module is included' do
+    let(:parametrized_class) do
+      INCLUDING_MODULE = including_module
+
+      Class.new(including_class) do
+        include INCLUDING_MODULE
+      end
+    end
+
+    let(:create_parameters) { { mixed_parameter: 5 } }
+
+    let(:instance) do
+      parametrized_class.new(create_parameters)
+    end
+
+    it 'returns value of module parameter' do
+      expect(instance.mixed_parameter).to be == '5'
+    end
+  end
+
+  context 'Class is inherited and extended with parameters' do
+    let(:parametrized_class) do
+      Class.new(including_class) do
+        parameter :all_properties_parameter,
+                  description: 'Made to test the situation when all ' \
+                    'properties are specified',
+                  getter: lambda { |p|
+                    options[p.name.to_s.sub('parameter', 'option').to_sym]
+                  },
+                  transform: ->(_, v) { v + 1 },
+                  constraint: ->(_, v) { raise "it's > 3!" if v > 3 }
+
+        parameter :bare_minimum,
+                  description: '"Do defaults" type of parameter'
+      end
+    end
+
+    it 'parameter objects have correct attributes' do
+      expect(parametrized_class.get_parameter(:all_properties_parameter).name)
+        .to be == :all_properties_parameter
+    end
+
+    describe 'DSL' do
+      it 'has parameter DSL method' do
+        expect(parametrized_class).to respond_to(:parameter)
+      end
+    end
+
+    context 'Instance of the class created' do
+      let(:create_parameters) {}
+
+      let(:instance) do
+        parametrized_class.new(create_parameters)
+      end
+
+      it 'contains all_properties_parameter as accessor' do
+        expect(instance).to respond_to(:all_properties_parameter)
+      end
+
+      it 'contains bare_minimum as accessor' do
+        expect(instance).to respond_to(:bare_minimum)
+      end
+
+      context 'with compliant parameters' do
+        let(:create_parameters) do
+          {
+            all_properties_option: 2,
+            bare_minimum: 5
+          }
+        end
+
+        it 'returns all_properties_parameter correctly' do
+          expect(instance.all_properties_parameter).to be == 3
+        end
+
+        it 'returns bare_minimum correctly' do
+          expect(instance.bare_minimum).to be == 5
+        end
+      end
+
+      context 'with parameters violating the constraint' do
+        let(:create_parameters) do
+          {
+            all_properties_option: 3,
+            bare_minimum: 5
+          }
+        end
+
+        it 'raises an exception' do
+          expect { instance.all_properties_parameter }.to raise_error RuntimeError
+        end
+      end
+    end
+
+    context 'Class is inherited and a parameter added' do
+      let(:extending_class) do
+        Class.new(parametrized_class) do
+          parameter :just_addition,
+                    description: 'Trying to add parameter to the ' \
+                      'parent\'s parameter list'
+        end
+      end
+
+      %i[just_addition all_properties_parameter bare_minimum].each do |name|
+        it "has accessor #{name} inherited from parent" do
+          expect(extending_class.method_defined?(name)).to be == true
+        end
+
+        it "has parameter #{name} inherited from parent" do
+          expect(extending_class.get_parameter(name).name).to be == name
+        end
+      end
+
+      context 'Instance of the class created' do
+        let(:create_parameters) do
+          {
+            all_properties_option: 2,
+            bare_minimum: 5,
+            just_addition: 'bonus'
+          }
+        end
+
+        let(:instance) do
+          extending_class.new(create_parameters)
+        end
+
+        {
+          all_properties_parameter: 3,
+          bare_minimum: 5,
+          just_addition: 'bonus'
+        }.each_pair do |name, value|
+          it "returns #{name} attributes correctly" do
+            expect(instance.send(name)).to be == value
+          end
+        end
+      end
+
+      context 'Class inherited and parameter mixin added' do
+        let(:mixing_class) do
+          k = Class.new(extending_class)
+          k.send(:include, including_module)
+          k
+        end
+
+        %i[just_addition all_properties_parameter bare_minimum].each do |name|
+          it "has accessor #{name} inherited from parent" do
+            expect(mixing_class.method_defined?(name)).to be == true
+          end
+
+          it "has parameter #{name} inherited from parent" do
+            expect(mixing_class.get_parameter(name).name).to be == name
+          end
+        end
+
+        it 'has accessor mixed_parameter derived from mixin' do
+          expect(mixing_class.method_defined?(:mixed_parameter)).to be == true
+        end
+
+        it 'has parameter mixed_parameter derived from mixin' do
+          expect(mixing_class.get_parameter(:mixed_parameter).name)
+            .to be == :mixed_parameter
+        end
+      end
+    end
+
+    it 'fails when trying to add existing parameter' do
+      expect do
+        Class.new(parametrized_class) do
+          parameter :bare_minimum, description: 'Something existing'
+        end
+      end.to raise_error Aws::Templates::ParameterAlreadyExist
+    end
+
+    context 'method is defined' do
+      let(:failing_class) do
+        Class.new(parametrized_class) do
+          def a; end
+        end
+      end
+
+      it 'fails when adding a parameter with the same name as a method' do
+        expect { failing_class.parameter(:a, description: 'Unexpected') }
+          .to raise_error Aws::Templates::ParameterMethodNameConflict
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'simplecov'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end