magicka 0.5.3 → 0.6.0

data/spec/lib/magicka/aggregator_spec.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Magicka::Aggregator do
+  subject(:aggregator) { aggregator_class.new(renderer, model) }
+
+  let(:aggregator_class) { Class.new(described_class) }
+  let(:model)            { :my_model }
+  let(:renderer)         { instance_double('renderer') }
+  let(:template)         { 'templates/forms/input' }
+  let(:locals)           { {} }
+
+  describe '.type' do
+    let(:type) { %w[form display other].sample }
+
+    it 'sets aggregator type' do
+      expect { aggregator_class.type(type) }
+        .to change(aggregator_class, :type)
+        .from(nil).to(type.to_sym)
+    end
+
+    context 'when type has not been set' do
+      let(:aggregator_class) do
+        Class.new(described_class) do
+          def self.name
+            'Magicka::MyClass'
+          end
+        end
+      end
+
+      it 'Uses class name as type' do
+        expect(aggregator_class.type)
+          .to eq(:my_class)
+      end
+    end
+  end
+
+  describe '.with_element' do
+    context 'when seeting element class only' do
+      it do
+        expect { aggregator_class.with_element(Magicka::Input) }
+          .to add_method(:input)
+          .to(aggregator)
+      end
+
+      context 'when built method is called' do
+        let(:template)    { 'templates/forms/input' }
+        let(:field)       { :field }
+        let(:label)       { 'Label' }
+        let(:placeholder) { 'Value' }
+
+        let(:locals) do
+          {
+            field: field,
+            label: label,
+            ng_errors: 'my_model.errors.field',
+            ng_model: 'my_model.field',
+            placeholder: placeholder
+          }
+        end
+
+        let(:arguments) do
+          {
+            label: label,
+            placeholder: placeholder
+          }
+        end
+
+        before do
+          aggregator_class.with_element(Magicka::Input)
+
+          allow(renderer)
+            .to receive(:render)
+            .with(partial: template, locals: locals)
+        end
+
+        it 'renders an input' do
+          aggregator.input(field, arguments)
+
+          expect(renderer).to have_received(:render)
+        end
+
+        context 'when passing a custom model' do
+          let(:locals) do
+            {
+              field: field,
+              label: label,
+              ng_errors: 'my_custom_model.errors.field',
+              ng_model: 'my_custom_model.field',
+              placeholder: placeholder
+            }
+          end
+
+          it 'renders an input' do
+            aggregator.input(field, model: 'my_custom_model', **arguments)
+
+            expect(renderer).to have_received(:render)
+          end
+        end
+      end
+    end
+
+    context 'when seeting element class and method' do
+      it do
+        expect { aggregator_class.with_element(Magicka::Input, :my_input) }
+          .to add_method(:my_input)
+          .to(aggregator)
+      end
+
+      context 'when built method is called' do
+        let(:template)    { 'templates/forms/input' }
+        let(:field)       { :field }
+        let(:label)       { 'Label' }
+        let(:placeholder) { 'Value' }
+
+        let(:locals) do
+          {
+            field: field,
+            label: label,
+            ng_errors: 'my_model.errors.field',
+            ng_model: 'my_model.field',
+            placeholder: placeholder
+          }
+        end
+
+        let(:arguments) do
+          {
+            label: label,
+            placeholder: placeholder
+          }
+        end
+
+        before do
+          aggregator_class.with_element(Magicka::Input, :my_input)
+
+          allow(renderer)
+            .to receive(:render)
+            .with(partial: template, locals: locals)
+        end
+
+        it 'renders an input' do
+          aggregator.my_input(field, arguments)
+
+          expect(renderer).to have_received(:render)
+        end
+
+        context 'when passing a custom model' do
+          let(:locals) do
+            {
+              field: field,
+              label: label,
+              ng_errors: 'my_custom_model.errors.field',
+              ng_model: 'my_custom_model.field',
+              placeholder: placeholder
+            }
+          end
+
+          it 'renders an input' do
+            aggregator.my_input(field, model: 'my_custom_model', **arguments)
+
+            expect(renderer).to have_received(:render)
+          end
+        end
+      end
+    end
+
+    context 'when seeting element class and template' do
+      it do
+        expect do
+          aggregator_class.with_element(Magicka::Input, template: template)
+        end
+          .to add_method(:input)
+          .to(aggregator)
+      end
+
+      context 'when built method is called' do
+        let(:template)    { 'my_templates/my_input' }
+        let(:field)       { :field }
+        let(:label)       { 'Label' }
+        let(:placeholder) { 'Value' }
+
+        let(:locals) do
+          {
+            field: field,
+            label: label,
+            ng_errors: 'my_model.errors.field',
+            ng_model: 'my_model.field',
+            placeholder: placeholder
+          }
+        end
+
+        let(:arguments) do
+          {
+            label: label,
+            placeholder: placeholder
+          }
+        end
+
+        before do
+          aggregator_class.with_element(Magicka::Input, template: template)
+
+          allow(renderer)
+            .to receive(:render)
+            .with(partial: template, locals: locals)
+        end
+
+        it 'renders an input' do
+          aggregator.input(field, arguments)
+
+          expect(renderer).to have_received(:render)
+        end
+
+        context 'when passing a custom model' do
+          let(:locals) do
+            {
+              field: field,
+              label: label,
+              ng_errors: 'my_custom_model.errors.field',
+              ng_model: 'my_custom_model.field',
+              placeholder: placeholder
+            }
+          end
+
+          it 'renders an input' do
+            aggregator.input(field, model: 'my_custom_model', **arguments)
+
+            expect(renderer).to have_received(:render)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#with_model' do
+    let(:expected_aggregator) do
+      aggregator_class.new(renderer, 'my_model.inner')
+    end
+
+    it do
+      aggregator.with_model(:inner) do |new_aggregator|
+        expect(new_aggregator).to eq(expected_aggregator)
+      end
+    end
+  end
+
+  describe '#only' do
+    let(:aggregator_class) do
+      Class.new(described_class) do
+        type :included
+      end
+    end
+
+    context 'when the type is included in the list' do
+      it 'executes the block' do
+        value = 0
+
+        aggregator.only(:not_included, :included, :other) { value += 1 }
+        expect(value).to eq(1)
+      end
+    end
+
+    context 'when the type is not included in the list' do
+      it 'does not execute the block' do
+        value = 0
+
+        aggregator.only(:not_included, :other) { value += 1 }
+        expect(value).to be_zero
+      end
+    end
+  end
+
+  describe '#except' do
+    let(:aggregator_class) do
+      Class.new(described_class) do
+        type :included
+      end
+    end
+
+    context 'when the type is included in the list' do
+      it 'does not execute the block' do
+        value = 0
+
+        aggregator.except(:not_included, :included, :other) { value += 1 }
+        expect(value).to be_zero
+      end
+    end
+
+    context 'when the type is not included in the list' do
+      it 'executes the block' do
+        value = 0
+
+        aggregator.except(:not_included, :other) { value += 1 }
+        expect(value).to eq(1)
+      end
+    end
+  end
+end

data/spec/lib/magicka/display_spec.rb

@@ -16,6 +16,12 @@ describe Magicka::Display do
       .with(partial: template, locals: locals)
   end
 
+  describe '.type' do
+    it do
+      expect(described_class.type).to eq(:display)
+    end
+  end
+
   describe '#input' do
     let(:template)    { 'templates/display/text' }
     let(:field)       { :field }
@@ -166,4 +172,44 @@ describe Magicka::Display do
       end
     end
   end
+
+  describe '#only' do
+    context 'when the type is included in the list' do
+      it 'executes the block' do
+        value = 0
+
+        form.only(:not_included, :display, :other) { value += 1 }
+        expect(value).to eq(1)
+      end
+    end
+
+    context 'when the type is not included in the list' do
+      it 'does not execute the block' do
+        value = 0
+
+        form.only(:not_included, :other) { value += 1 }
+        expect(value).to be_zero
+      end
+    end
+  end
+
+  describe '#except' do
+    context 'when the type is included in the list' do
+      it 'does not execute the block' do
+        value = 0
+
+        form.except(:not_included, :display, :other) { value += 1 }
+        expect(value).to be_zero
+      end
+    end
+
+    context 'when the type is not included in the list' do
+      it 'executes the block' do
+        value = 0
+
+        form.except(:not_included, :other) { value += 1 }
+        expect(value).to eq(1)
+      end
+    end
+  end
 end

data/spec/lib/magicka/element_spec.rb

@@ -82,5 +82,46 @@ describe Magicka::Element do
         expect(renderer).to have_received(:render)
       end
     end
+
+    context 'when class has a template but is initialized with template' do
+      subject(:element) do
+        klass.new(renderer: renderer, template: custom_template)
+      end
+
+      let(:custom_template) { 'custom_folder/custom_template' }
+      let(:expected_template) { custom_template }
+
+      before do
+        klass.template(template)
+      end
+
+      it do
+        element.render
+
+        expect(renderer).to have_received(:render)
+      end
+    end
+
+    context 'when class has folder but is initialized with template' do
+      subject(:element) do
+        klass.new(renderer: renderer, template: custom_template)
+      end
+
+      let(:custom_template)   { 'custom_folder/custom_template' }
+      let(:expected_template) { custom_template }
+
+      before do
+        klass.template_folder(folder)
+
+        method_builder.add_class_method(:name) { 'Magicka::MyElement' }
+        method_builder.build
+      end
+
+      it do
+        element.render
+
+        expect(renderer).to have_received(:render)
+      end
+    end
   end
 end

data/spec/lib/magicka/form_spec.rb

@@ -16,6 +16,12 @@ describe Magicka::Form do
       .with(partial: template, locals: locals)
   end
 
+  describe '.type' do
+    it do
+      expect(described_class.type).to eq(:form)
+    end
+  end
+
   describe '#input' do
     let(:template)    { 'templates/forms/input' }
     let(:field)       { :field }
@@ -180,4 +186,44 @@ describe Magicka::Form do
       end
     end
   end
+
+  describe '#only' do
+    context 'when the type is included in the list' do
+      it 'executes the block' do
+        value = 0
+
+        form.only(:not_included, :form, :other) { value += 1 }
+        expect(value).to eq(1)
+      end
+    end
+
+    context 'when the type is not included in the list' do
+      it 'does not execute the block' do
+        value = 0
+
+        form.only(:not_included, :other) { value += 1 }
+        expect(value).to be_zero
+      end
+    end
+  end
+
+  describe '#except' do
+    context 'when the type is included in the list' do
+      it 'does not execute the block' do
+        value = 0
+
+        form.except(:not_included, :form, :other) { value += 1 }
+        expect(value).to be_zero
+      end
+    end
+
+    context 'when the type is not included in the list' do
+      it 'executes the block' do
+        value = 0
+
+        form.except(:not_included, :other) { value += 1 }
+        expect(value).to eq(1)
+      end
+    end
+  end
 end

data/spec/lib/magicka/helper_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Magicka::Helper do
+  subject(:object) { klass.new }
+
+  let(:klass) do
+    Class.new do
+      include Magicka::Helper
+    end
+  end
+
+  let(:model) { 'model' }
+
+  describe '.with' do
+    let(:aggregator_class) do
+      Class.new(Magicka::Aggregator) do
+        def self.name
+          'Magicka::MyClass'
+        end
+      end
+    end
+
+    it do
+      expect { described_class.with(aggregator_class) }
+        .to add_method('magicka_my_class')
+        .to(object)
+    end
+  end
+
+  describe '#magicka_display' do
+    it do
+      object.magicka_display(model) do |display|
+        expect(display).to be_a(Magicka::Display)
+      end
+    end
+
+    it 'populates the model' do
+      object.magicka_display(model) do |display|
+        expect(display.model).to eq(model)
+      end
+    end
+
+    it 'populates the renderer' do
+      object.magicka_display(model) do |display|
+        expect(display.send(:renderer)).to eq(object)
+      end
+    end
+  end
+
+  describe '#magicka_form' do
+    it do
+      object.magicka_form(model) do |form|
+        expect(form).to be_a(Magicka::Form)
+      end
+    end
+
+    it 'populates the model' do
+      object.magicka_form(model) do |form|
+        expect(form.model).to eq(model)
+      end
+    end
+
+    it 'populates the renderer' do
+      object.magicka_form(model) do |form|
+        expect(form.send(:renderer)).to eq(object)
+      end
+    end
+  end
+end