cloud-templates 0.1.0

data/spec/aws/templates/composite_spec.rb

@@ -0,0 +1,361 @@
+require 'spec_helper'
+require 'aws/templates/composite'
+
+class A
+  attr_reader :params
+
+  def label
+    @params[:label]
+  end
+
+  def initialize(p)
+    @params = p
+  end
+
+  def eql?(other)
+    (self.class == other.class) && (params.to_hash == other.params.to_hash)
+  end
+
+  def ==(other)
+    eql?(other)
+  end
+
+  def !=(other)
+    !eql?(other)
+  end
+end
+
+describe Aws::Templates::Composite do
+  let(:composite_class) do
+    Class.new(Aws::Templates::Composite) do
+      default rocket: 'spacehawk'
+      default spaceship: 'martyr'
+
+      contextualize filter(:copy) &
+                    { erased: 'forever' } &
+                    (filter(:override) { { root: self } })
+
+      components do
+        artifact A, label: 'b'
+        artifact A, label: 'a', w: artifact(A, label: 'z')
+        artifact A, label: 'y', w: artifact(A, label: 'x').not_a_dependency
+        artifact(
+          A,
+          filter(:override) { { boomer: options[:rocket].upcase, vehicle: options[:spaceship] } } &
+          { label: 'c' }
+        )
+      end
+    end
+  end
+
+  let(:parameters) { { label: 'q' } }
+
+  let(:artifacts) do
+    instance.artifacts.each_with_object({}) { |(k, v), memo| memo[k] = v.params.to_hash }
+  end
+
+  context 'a parameter is overriden' do
+    let(:instance) { composite_class.new(parameters) }
+
+    let(:result) do
+      {
+        'z' => {
+          label: 'z',
+          rocket: 'serenity',
+          spaceship: 'martyr',
+          erased: 'forever',
+          root: instance,
+          parent: instance
+        },
+        'x' => {
+          label: 'x',
+          rocket: 'serenity',
+          spaceship: 'martyr',
+          erased: 'forever',
+          root: instance,
+          parent: instance
+        },
+        'b' => {
+          label: 'b',
+          rocket: 'serenity',
+          spaceship: 'martyr',
+          erased: 'forever',
+          root: instance,
+          parent: instance
+        },
+        'a' => {
+          label: 'a',
+          rocket: 'serenity',
+          spaceship: 'martyr',
+          erased: 'forever',
+          w: Aws::Templates::Utils::Dependency.new(
+            A.new(
+              label: 'z',
+              rocket: 'serenity',
+              spaceship: 'martyr',
+              erased: 'forever',
+              root: instance,
+              parent: instance
+            )
+          ),
+          root: instance,
+          parent: instance
+        },
+        'y' => {
+          label: 'y',
+          rocket: 'serenity',
+          spaceship: 'martyr',
+          erased: 'forever',
+          w: A.new(
+            label: 'x',
+            rocket: 'serenity',
+            spaceship: 'martyr',
+            erased: 'forever',
+            root: instance,
+            parent: instance
+          ),
+          root: instance,
+          parent: instance
+        },
+        'c' => {
+          label: 'y',
+          rocket: 'serenity',
+          spaceship: 'martyr',
+          boomer: 'SERENITY',
+          vehicle: 'martyr',
+          erased: 'forever',
+          root: instance,
+          parent: instance
+        }
+      }
+    end
+
+    before { parameters[:rocket] = 'serenity' }
+
+    it 'has predictable parameters distribution' do
+      v = instance['b'].params.to_hash
+      expect(v).to be == result['b']
+    end
+
+    it 'throws exception when unknown artifact is being extracted' do
+      expect { instance['w'] }.to raise_error RuntimeError, /There is no artifact/
+    end
+
+    it 'has all expected artifacts' do
+      expect(artifacts['a']).to be == result['a']
+    end
+  end
+
+  describe 'search' do
+    let(:instance) do
+      artifact_class = Class.new(Aws::Templates::Artifact) { parameter :yoke }
+      nested_class = composite_class
+      composite_class.new(parameters).components do
+        artifact artifact_class,
+                 label: 'w',
+                 yoke: Struct.new(:one, :two).new('fruit', 'veggie')
+        artifact nested_class, label: 'r'
+      end
+    end
+
+    describe 'search by label' do
+      let(:found_artifacts) { instance.search(label: 'c') }
+
+      it 'is only one artifact labeled c' do
+        expect(found_artifacts.size).to be == 1
+      end
+
+      it 'finds correct artifact' do
+        expect(found_artifacts.first.params[:boomer]).to be == 'SPACEHAWK'
+      end
+    end
+
+    describe 'search by field' do
+      let(:found_artifacts) { instance.search(parameters: { yoke: { two: 'veggie' } }) }
+
+      it 'is only one artifact which has field set' do
+        expect(found_artifacts.size).to be == 1
+      end
+
+      it 'finds correct artifact' do
+        v = found_artifacts.first
+        expect(v.yoke.two).to be == 'veggie'
+      end
+    end
+
+    describe 'search by class' do
+      let(:found_artifacts) { instance.search(klass: A) }
+
+      it 'has 3 found artifacts' do
+        expect(found_artifacts.size).to be == 6
+      end
+
+      it 'finds correct artifacts' do
+        expect(found_artifacts.map(&:label).sort).to be == %w[a b c x y z]
+      end
+    end
+
+    describe 'search recursively' do
+      let(:found_artifacts) { instance.search(klass: A, recursive: true) }
+
+      it 'has 6 found artifacts' do
+        expect(found_artifacts.size).to be == 12
+      end
+
+      it 'finds correct artifacts' do
+        expect(found_artifacts.map(&:label).sort).to be == %w[a a b b c c x x y y z z]
+      end
+    end
+  end
+
+  describe 'adding artifacts' do
+    shared_examples 'an artifact storage' do
+      it 'contains artifact t' do
+        expect(instance['t'].params.to_hash).to be == result['t']
+      end
+
+      it 'contains expected artifacts' do
+        expect(artifacts).to be == result
+      end
+    end
+
+    before { parameters[:postfix] = 'X' }
+
+    let(:result) do
+      {
+        'z' => {
+          label: 'z',
+          rocket: 'spacehawk',
+          spaceship: 'martyr',
+          erased: 'forever',
+          postfix: 'X',
+          root: instance,
+          parent: instance
+        },
+        'x' => {
+          label: 'x',
+          rocket: 'spacehawk',
+          spaceship: 'martyr',
+          erased: 'forever',
+          postfix: 'X',
+          root: instance,
+          parent: instance
+        },
+        'b' => {
+          label: 'b',
+          rocket: 'spacehawk',
+          spaceship: 'martyr',
+          erased: 'forever',
+          postfix: 'X',
+          root: instance,
+          parent: instance
+        },
+        'a' => {
+          label: 'a',
+          rocket: 'spacehawk',
+          spaceship: 'martyr',
+          erased: 'forever',
+          postfix: 'X',
+          w: Aws::Templates::Utils::Dependency.new(
+            A.new(
+              label: 'z',
+              rocket: 'spacehawk',
+              spaceship: 'martyr',
+              erased: 'forever',
+              postfix: 'X',
+              root: instance,
+              parent: instance
+            )
+          ),
+          root: instance,
+          parent: instance
+        },
+        'y' => {
+          label: 'y',
+          rocket: 'spacehawk',
+          spaceship: 'martyr',
+          erased: 'forever',
+          postfix: 'X',
+          w: A.new(
+            label: 'x',
+            rocket: 'spacehawk',
+            spaceship: 'martyr',
+            erased: 'forever',
+            postfix: 'X',
+            root: instance,
+            parent: instance
+          ),
+          root: instance,
+          parent: instance
+        },
+        'c' => {
+          label: 'c',
+          rocket: 'spacehawk',
+          spaceship: 'martyr',
+          boomer: 'SPACEHAWK',
+          vehicle: 'martyr',
+          erased: 'forever',
+          postfix: 'X',
+          root: instance,
+          parent: instance
+        },
+        't' => {
+          label: 't',
+          rocket: 'spacehawk',
+          spaceship: 'martyr',
+          rumba: 'SPACEHAWKX',
+          postfix: 'X',
+          erased: 'forever',
+          root: instance,
+          parent: instance
+        }
+      }
+    end
+
+    context 'using constructor block' do
+      let(:instance) do
+        composite_class.new(parameters) do
+          artifact(
+            A,
+            filter(:override) { { rumba: artifacts['c'].params[:boomer] + options[:postfix] } } &
+            { label: 't' }
+          )
+        end
+      end
+
+      it_behaves_like 'an artifact storage'
+    end
+
+    context 'using instance components method' do
+      let(:instance) do
+        composite_class.new(parameters).components do
+          artifact(
+            A,
+            filter(:override) { { rumba: artifacts['c'].params[:boomer] + options[:postfix] } } &
+            { label: 't' }
+          )
+        end
+      end
+
+      it_behaves_like 'an artifact storage'
+    end
+
+    context 'using subclass' do
+      let(:subclass) do
+        Class.new(composite_class) do
+          components do
+            artifact(
+              A,
+              filter(:override) { { rumba: artifacts['c'].params[:boomer] + options[:postfix] } } &
+              { label: 't' }
+            )
+          end
+        end
+      end
+
+      let(:instance) { subclass.new(parameters) }
+
+      it_behaves_like 'an artifact storage'
+    end
+  end
+end

data/spec/aws/templates/render/utils/base_type_views_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'aws/templates/render/utils/base_type_views'
+require 'aws/templates/render'
+
+include Aws::Templates::Render::Utils::BaseTypeViews
+
+describe Aws::Templates::Render::Utils::BaseTypeViews do
+  let(:render) do
+    Module.new do
+      extend Aws::Templates::Render
+    end
+  end
+
+  describe 'AsIs' do
+    before { render.define_view(Object, AsIs) }
+
+    it 'renders string' do
+      expect(render.view_for('123').to_rendered).to be == '123'
+    end
+
+    it 'renders random object' do
+      expect(render.view_for([123]).to_rendered).to be == [123]
+    end
+  end
+
+  describe 'ToString' do
+    before { render.define_view(Object, ToString) }
+
+    it 'renders string' do
+      expect(render.view_for('123').to_rendered).to be == '123'
+    end
+
+    it 'renders number' do
+      expect(render.view_for(123).to_rendered).to be == '123'
+    end
+  end
+
+  describe 'ToArray' do
+    before do
+      render.define_view(Array, ToArray)
+      render.define_view(Object, ToString)
+    end
+
+    it 'renders array' do
+      expect(render.view_for([[1, 2, 3], '123']).to_rendered).to be == [%w[1 2 3], '123']
+    end
+  end
+
+  describe 'ToHash' do
+    before do
+      render.define_view(Object, ToString)
+      render.define_view(Hash, ToHash)
+    end
+
+    it 'renders hash' do
+      expect(render.view_for(q: 1, w: { e: 2, r: 3 }).to_rendered)
+        .to be == { 'q' => '1', 'w' => { 'e' => '2', 'r' => '3' } }
+    end
+  end
+
+  describe 'ToFloat' do
+    before { render.define_view(Object, ToFloat) }
+
+    it 'renders integer' do
+      expect(render.view_for(1).to_rendered).to be == 1.0
+    end
+
+    it 'renders string' do
+      expect(render.view_for('1.3').to_rendered).to be == 1.3
+    end
+  end
+
+  describe 'ToInteger' do
+    before { render.define_view(Object, ToInteger) }
+
+    it 'renders float' do
+      expect(render.view_for(1.3).to_rendered).to be == 1
+    end
+
+    it 'renders string' do
+      expect(render.view_for('23').to_rendered).to be == 23
+    end
+  end
+
+  describe 'ToBoolean' do
+    before { render.define_view(Object, ToBoolean) }
+
+    it 'renders random object' do
+      expect(render.view_for([]).to_rendered).to be == true
+    end
+
+    it 'renders false' do
+      expect(render.view_for(false).to_rendered).to be == false
+    end
+
+    it 'renders false as a string' do
+      expect(render.view_for('false').to_rendered).to be == false
+    end
+
+    it 'renders true' do
+      expect(render.view_for(true).to_rendered).to be == true
+    end
+  end
+end

data/spec/aws/templates/render_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'aws/templates/render'
+
+describe Aws::Templates::Render do
+  let(:render) do
+    Module.new { extend Aws::Templates::Render }
+  end
+
+  let(:artifact_class) { Class.new }
+
+  let(:child_artifact_class1) { Class.new(artifact_class) }
+
+  let(:child_artifact_class2) { Class.new(artifact_class) }
+
+  let(:unknown_artifact) { Class.new }
+
+  let(:view1) do
+    k = Class.new(Aws::Templates::Render::View) do
+      def initialize(arg, params); end
+
+      def to_rendered
+        'Render 1'
+      end
+    end
+
+    k.register_in(render).artifact(artifact_class)
+  end
+
+  let(:view2) do
+    k = Class.new(view1) do
+      def to_rendered
+        'Render 2'
+      end
+    end
+
+    k.artifact(child_artifact_class1)
+  end
+
+  before do
+    view1
+    view2
+  end
+
+  it 'renders class correctly' do
+    expect(render.view_for(artifact_class.new).to_rendered).to be == 'Render 1'
+  end
+
+  it 'renders child class correctly' do
+    expect(render.view_for(child_artifact_class1.new).to_rendered)
+      .to be == 'Render 2'
+  end
+
+  it 'renders yet another child class correctly' do
+    expect(render.view_for(child_artifact_class2.new).to_rendered)
+      .to be == 'Render 1'
+  end
+
+  it 'throws an error once no classes are found' do
+    expect { render.view_for(unknown_artifact.new).to_rendered }
+      .to raise_error Aws::Templates::ViewNotFound
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'aws/templates/utils/named'
+require 'aws/templates/utils/parametrized/getters'
+
+describe Aws::Templates::Utils::AsNamed do
+  let(:named_class) do
+    Class.new do
+      include Aws::Templates::Utils::Parametrized
+
+      include Aws::Templates::Utils::AsNamed
+
+      attr_reader :options
+
+      def self.getter
+        as_is
+      end
+
+      def initialize(hsh)
+        @options = hsh
+      end
+    end
+  end
+
+  it 'returns name' do
+    expect(named_class.new(name: 'orugva').name).to be == 'orugva'
+  end
+
+  it 'fails when name is not provided' do
+    expect { named_class.new({}).name }.to raise_error(/Name of the object/)
+  end
+end

data/spec/aws/templates/utils/contextualized/filters_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'aws/templates/utils/contextualized'
+require 'aws/templates/utils/options'
+
+describe Aws::Templates::Utils::Contextualized::Filter do
+  let(:filtered_class) do
+    Class.new do
+      include Aws::Templates::Utils::Contextualized
+    end
+  end
+
+  let(:test_class) {}
+
+  let(:instance) { test_class.new }
+
+  describe 'override' do
+    let(:test_class) do
+      Class.new(filtered_class) do
+        contextualize a: 'awesome'
+      end
+    end
+
+    it 'adds element into hash' do
+      opts = Aws::Templates::Utils::Options.new(b: 2, c: 3)
+      expect(opts.filter(&instance.context).to_hash).to be == { a: 'awesome' }
+    end
+
+    context 'when full context copied' do
+      let(:test_class) do
+        Class.new(filtered_class) do
+          contextualize filter(:copy) & { a: 'awesome' }
+        end
+      end
+
+      it 'overrides element in the hash' do
+        opts = Aws::Templates::Utils::Options.new(a: 1, b: 2, c: 3)
+        expect(opts.filter(&instance.context).to_hash).to be == { a: 'awesome', b: 2, c: 3 }
+      end
+    end
+  end
+
+  describe 'remove' do
+    let(:test_class) do
+      Class.new(filtered_class) do
+        contextualize filter(:copy) & filter(:remove, :a, r: [:x])
+      end
+    end
+
+    it 'does nothing to hash without elements to remove' do
+      opts = Aws::Templates::Utils::Options.new(b: 2, c: 3)
+      expect(opts.filter(&instance.context).to_hash).to be == { b: 2, c: 3 }
+    end
+
+    it 'removes specified key from hash' do
+      opts = Aws::Templates::Utils::Options.new(a: 1, b: 2, c: 3, r: { x: 1, z: 0 })
+      expect(opts.filter(&instance.context).to_hash).to be == { b: 2, c: 3, r: { z: 0 } }
+    end
+  end
+
+  describe 'add' do
+    let(:test_class) do
+      Class.new(filtered_class) do
+        contextualize filter(:add, :a, r: [:x])
+      end
+    end
+
+    it 'adds the only key found' do
+      opts = Aws::Templates::Utils::Options.new(a: 1, b: 2, c: 3)
+      expect(opts.filter(&instance.context).to_hash).to be == { a: 1 }
+    end
+
+    it 'adds specified keys from hash' do
+      opts = Aws::Templates::Utils::Options.new(a: 1, b: 2, c: 3, r: { x: 1, z: 0 })
+      expect(opts.filter(&instance.context).to_hash).to be == { a: 1, r: { x: 1 } }
+    end
+  end
+
+  describe 'chain' do
+    let(:test_class) do
+      Class.new(filtered_class) do
+        contextualize filter(:copy) & filter(:remove, :a) & filter(:override, f: 10)
+      end
+    end
+
+    it 'does nothing to hash without elements to remove' do
+      opts = Aws::Templates::Utils::Options.new(b: 2, c: 3)
+      expect(opts.filter(&instance.context).to_hash).to be == { b: 2, c: 3, f: 10 }
+    end
+
+    it 'removes specified key from hash' do
+      opts = Aws::Templates::Utils::Options.new(a: 1, b: 2, c: 3)
+      expect(opts.filter(&instance.context).to_hash).to be == { b: 2, c: 3, f: 10 }
+    end
+  end
+
+  describe 'identity' do
+    let(:test_class) do
+      Class.new(filtered_class) do
+        contextualize filter(:copy) & filter(:identity)
+      end
+    end
+
+    it 'adds element into hash' do
+      opts = Aws::Templates::Utils::Options.new(b: 2, c: 3)
+      expect(opts.filter(&instance.context).to_hash).to be == { b: 2, c: 3 }
+    end
+  end
+end