cloud-templates 0.1.0

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

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'aws/templates/utils/contextualized'
+require 'aws/templates/utils/options'
+
+describe Aws::Templates::Utils::Contextualized do
+  let(:including_class) do
+    Class.new do
+      include Aws::Templates::Utils::Contextualized
+
+      contextualize ->(opts, _) { opts.dup }
+    end
+  end
+
+  let(:including_module) do
+    Module.new do
+      include Aws::Templates::Utils::Contextualized
+
+      contextualize lambda { |_, memo|
+        memo.delete(:z)
+        memo
+      }
+    end
+  end
+
+  describe 'module include' do
+    it 'has filter DSL method' do
+      expect(including_module).to respond_to(:contextualize)
+    end
+  end
+
+  describe 'class include' do
+    it 'has parameter DSL method' do
+      expect(including_class).to respond_to(:contextualize)
+    end
+  end
+
+  context 'Class is inherited and the module is included' do
+    let(:parametrized_class) do
+      klass = Class.new(including_class)
+      klass.send(:include, including_module)
+      klass
+    end
+
+    let(:instance) { parametrized_class.new }
+
+    let(:options) { Aws::Templates::Utils::Options.new(a: 5, z: 10) }
+
+    it 'returns properly filtered options' do
+      expect(options.filter(&instance.context).to_hash).to be == { a: 5 }
+    end
+  end
+
+  context 'Class is inherited and extended with filters' do
+    let(:parametrized_class) do
+      Class.new(including_class) do
+        contextualize lambda { |_, memo|
+          memo.delete(:r)
+          memo
+        }
+
+        contextualize lambda { |_, memo|
+          memo[:x] = memo[:a] + 1
+          memo
+        }
+      end
+    end
+
+    let(:options) { Aws::Templates::Utils::Options.new(a: 3, r: 5, z: 7) }
+
+    describe 'DSL' do
+      it 'has filter DSL method' do
+        expect(parametrized_class).to respond_to(:contextualize)
+      end
+    end
+
+    context 'Instance of the class created' do
+      let(:instance) { parametrized_class.new }
+
+      it 'filters it according to specified parameters' do
+        expect(options.filter(&instance.context).to_hash).to be == { a: 3, z: 7, x: 4 }
+      end
+    end
+
+    context 'Class is inherited and a filter added' do
+      let(:extending_class) do
+        Class.new(parametrized_class) do
+          contextualize lambda { |_, memo|
+            memo[:w] = memo[:z] + memo[:x]
+            memo
+          }
+        end
+      end
+
+      let(:instance) { extending_class.new }
+
+      it 'filters it according to specified parameters' do
+        expect(options.filter(&instance.context).to_hash).to be == { a: 3, z: 7, x: 4, w: 11 }
+      end
+
+      context 'Class inherited and a filtered mixin added' do
+        let(:mixing_class) do
+          k = Class.new(extending_class)
+          k.send(:include, including_module)
+          k
+        end
+
+        let(:instance) { mixing_class.new }
+
+        it 'filters it according to specified parameters' do
+          expect(options.filter(&instance.context).to_hash).to be == { a: 3, x: 4, w: 11 }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'aws/templates/utils/late_bound'
+
+describe Aws::Templates::Utils::LateBound do
+  let(:including_class) do
+    Class.new do
+      include Aws::Templates::Utils::LateBound
+    end
+  end
+
+  let(:instance) { including_class.new }
+
+  describe 'DSL' do
+    it 'has parameter DSL class-level method' do
+      expect(including_class).to respond_to(:reference)
+    end
+
+    it 'has parameter DSL instance-level method' do
+      expect(including_class.new).to respond_to(:reference)
+    end
+  end
+
+  describe 'behavior' do
+    context 'class' do
+      let(:reference) { including_class.reference(%i[a b c], explosive: true) }
+
+      let(:evaluated) { instance.instance_exec(&reference) }
+
+      it 'creates proc for reference' do
+        expect(reference).to be_a Proc
+      end
+
+      it 'is evaluated into normal reference' do
+        expect(evaluated).to be_a Aws::Templates::Utils::LateBound::Reference
+      end
+
+      it 'contains assigned attributes' do
+        expect([evaluated.path, evaluated.arguments, evaluated.instance])
+          .to be == [%i[a b c], [{ explosive: true }], instance]
+      end
+    end
+
+    context 'instance' do
+      let(:reference) { instance.reference(%i[a b c], explosive: true) }
+
+      it 'is evaluated into normal reference' do
+        expect([reference.path, reference.arguments, reference.instance])
+          .to be == [%i[a b c], [{ explosive: true }], instance]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'aws/templates/utils/options'
+
+describe Aws::Templates::Utils::Options do
+  let(:options) do
+    described_class.new(
+      a: 1,
+      b: { c: 2 },
+      d: { c: { z: 3 } },
+      :* => { c: { :* => 5 } }
+    )
+  end
+
+  describe 'merge' do
+    let(:merged_options) do
+      options.merge(a: 12, b: { w: 30 }, d: { c: { z: 34 } })
+    end
+
+    let(:result) do
+      {
+        a: 12,
+        b: { c: 2, w: 30 },
+        d: { c: { z: 34 } },
+        :* => { c: { :* => 5 } }
+      }
+    end
+
+    it 'has correct class' do
+      expect(merged_options).to be_a_kind_of(described_class)
+    end
+
+    it 'merges according to the algorithm' do
+      expect(merged_options.to_hash).to be == result
+    end
+  end
+
+  describe 'lookup' do
+    it 'returns value when simple path is specified' do
+      expect(options[:b, :c]).to be == 2
+    end
+
+    it 'return nil when value is not found' do
+      expect(options[:b, :d, :z]).to be_nil
+    end
+
+    it 'wildcard lookup works' do
+      expect(options[:q, :c, :e]).to be == 5
+    end
+  end
+
+  describe 'assignment' do
+    it 'existing path assignment works' do
+      options[:b, :c] = 3
+      expect(options[:b, :c]).to be == 3
+    end
+
+    it 'new path assignment works' do
+      options[:b, :z, :y, :d] = 10
+      expect(options[:b, :z, :y, :d]).to be == 10
+    end
+
+    it 'throws an exception when value is not hash' do
+      options[:b, :c, :y, :d] = 13
+      expect(options[:b, :c, :y, :d]).to be == 13
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'aws/templates/utils/parametrized'
+require 'aws/templates/utils/parametrized/constraints'
+require 'aws/templates/utils/parametrized/getters'
+
+module Constraints
+  include Aws::Templates::Utils::Parametrized
+end
+
+describe Aws::Templates::Utils::Parametrized::Constraint do
+  let(:constraint) {}
+
+  let(:parametrized_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(:test_class) do
+    k = Class.new(parametrized_class)
+    k.parameter(:something, constraint: constraint)
+    k
+  end
+
+  describe 'not_nil' do
+    let(:constraint) { Constraints.not_nil }
+
+    it 'passes when non-nil value is specified' do
+      expect(test_class.new(something: 1).something).to be == 1
+    end
+
+    it 'throws error when parameter is not specified' do
+      expect { test_class.new(something_else: 1).something }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+  end
+
+  describe 'enum works as expected' do
+    let(:constraint) { Constraints.enum(1, 2, 3) }
+
+    it 'passes when a value from the list is specifed' do
+      expect(test_class.new(something: 2).something).to be == 2
+    end
+
+    it 'passes when value is not specified' do
+      expect(test_class.new(something_else: 2).something).to be_nil
+    end
+
+    it 'throws an error when a value is specified which is not a member of the enumeration' do
+      expect { test_class.new(something: 5).something }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+  end
+
+  describe 'all_of' do
+    let(:constraint) { Constraints.all_of(Constraints.not_nil, Constraints.enum(1, 2, 3)) }
+
+    it 'passes if all constraints are met' do
+      expect(test_class.new(something: 2).something).to be == 2
+    end
+
+    it 'throws an error if one of the constraints are failed (not_nil)' do
+      expect { test_class.new(something_else: 2).something }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+
+    it 'throws an error if one of the constraints are failed (enum)' do
+      expect { test_class.new(something: 5).something }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+  end
+
+  describe 'requires' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something, constraint: requires(:requirement)
+        parameter :requirement, description: 'Nothing'
+      end
+    end
+
+    it 'passes when requirement is satisfied' do
+      expect(test_class.new(something: 2, requirement: 1).something).to be == 2
+    end
+
+    it 'passes if value is nil so no requirements are enforced' do
+      expect(test_class.new({}).something).to be_nil
+    end
+
+    it 'throws an error when requirement is not satisfied' do
+      expect { test_class.new(something: 5).something }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+  end
+
+  describe 'depends_on_value' do
+    let(:test_class) do
+      Class.new(parametrized_class) do
+        parameter :something,
+                  constraint: depends_on_value(
+                    requirement: requires(:requirement),
+                    condition: requires(:condition)
+                  )
+        parameter :requirement, description: 'Nothing'
+        parameter :condition, description: 'Nothing'
+      end
+    end
+
+    it 'passes when nil' do
+      expect(test_class.new({}).something).to be_nil
+    end
+
+    it 'passes when value is not one of the conditions' do
+      expect(test_class.new(something: 2).something).to be == 2
+    end
+
+    it 'passes when conditional constraint is met' do
+      expect(test_class.new(something: :condition, condition: 2).something)
+        .to be == :condition
+    end
+
+    it 'throws an error when conditional constraint is not met' do
+      expect { test_class.new(something: :condition, requirement: 2).something }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+
+    it 'passes when other conditional constraint is met' do
+      expect(test_class.new(something: :requirement, requirement: 2).something)
+        .to be == :requirement
+    end
+  end
+
+  describe 'satisfies' do
+    let(:constraint) { Constraints.satisfies('some interesting case') { |v| v > 3 } }
+
+    it 'passes when nil' do
+      expect(test_class.new({}).something).to be_nil
+    end
+
+    it 'passes when condition is satisfied' do
+      expect(test_class.new(something: 4).something).to be == 4
+    end
+
+    it 'throws an error when condition is not satisfied' do
+      expect { test_class.new(something: 1).something }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+  end
+
+  describe 'matches' do
+    let(:constraint) { Constraints.matches('[Tt]$') }
+
+    it 'passes when nil' do
+      expect(test_class.new({}).something).to be_nil
+    end
+
+    it 'passes when condition is satisfied' do
+      expect(test_class.new(something: 'rest').something).to be == 'rest'
+    end
+
+    it 'throws an error when condition is not satisfied' do
+      expect { test_class.new(something: 'rooster').something }
+        .to raise_error Aws::Templates::ParameterValueInvalid
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'aws/templates/utils/parametrized'
+require 'aws/templates/utils/parametrized/getters'
+
+module Getters
+  include Aws::Templates::Utils::Parametrized
+end
+
+describe Aws::Templates::Utils::Parametrized::Getter do
+  let(:parametrized_class) do
+    Class.new do
+      include Aws::Templates::Utils::Parametrized
+
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+    end
+  end
+
+  let(:options_hash) {}
+
+  let(:getter) {}
+
+  let(:test_class) do
+    k = Class.new(parametrized_class)
+    k.parameter(:something, getter: getter)
+    k
+  end
+
+  let(:instance) { test_class.new(options_hash) }
+
+  describe 'as_instance_variable' do
+    let(:parametrized_class) do
+      Class.new do
+        include Aws::Templates::Utils::Parametrized
+
+        def initialize(something)
+          @something = something
+        end
+      end
+    end
+
+    let(:options_hash) { 'a' }
+
+    let(:getter) { Getters.as_instance_variable }
+
+    it 'returns the value from hash by parameter name' do
+      expect(instance.something).to be == 'a'
+    end
+  end
+
+  describe 'as_is' do
+    let(:options_hash) { { something: 'a' } }
+
+    let(:getter) { Getters.as_is }
+
+    it 'returns the value from hash by parameter name' do
+      expect(instance.something).to be == 'a'
+    end
+  end
+
+  describe 'path' do
+    let(:options_hash) do
+      hash = { object: { something: 'a' } }
+
+      class << hash
+        def [](*path)
+          if path.size == 1
+            super(path[0])
+          else
+            path.inject(self) { |acc, elem| acc[elem] }
+          end
+        end
+      end
+
+      hash
+    end
+
+    context 'static path is specified' do
+      let(:getter) { Getters.path(:object, :something) }
+
+      it 'returns value correctly' do
+        expect(instance.something).to be == 'a'
+      end
+    end
+
+    context 'dynamic path is specified' do
+      let(:getter) { Getters.path { %i[object something] } }
+
+      it 'returns value correctly' do
+        expect(instance.something).to be == 'a'
+      end
+    end
+  end
+
+  describe 'value' do
+    let(:options_hash) { { something: 3 } }
+
+    context 'static value is specified' do
+      let(:getter) { Getters.value(1) }
+
+      it 'returns value correctly' do
+        expect(instance.something).to be == 1
+      end
+    end
+
+    context 'dynamic calculation is specified' do
+      let(:getter) { Getters.value { options[:something] + 2 } }
+
+      it 'returns value correctly' do
+        expect(instance.something).to be == 5
+      end
+    end
+  end
+
+  describe 'one_of' do
+    let(:getter) do
+      Getters.one_of(->(p) { options[p.name] }, ->(_) { options[:default] })
+    end
+
+    context 'first option value is specified' do
+      let(:options_hash) { { something: 'a' } }
+
+      it 'returns the value' do
+        expect(instance.something).to be == 'a'
+      end
+    end
+
+    context 'another options value is specified' do
+      let(:options_hash) { { default: 'a' } }
+
+      it 'returns the value' do
+        expect(instance.something).to be == 'a'
+      end
+    end
+  end
+end