active_interaction 0.1.1

data/lib/active_interaction/overload_hash.rb

@@ -0,0 +1,11 @@
+module ActiveInteraction
+  module OverloadHash
+    def hash(*args, &block)
+      if args.empty? && !block_given?
+        super
+      else
+        method_missing(:hash, *args, &block)
+      end
+    end
+  end
+end

data/lib/active_interaction/version.rb

@@ -0,0 +1,3 @@
+module ActiveInteraction
+  VERSION = Gem::Version.new('0.1.1')
+end

data/spec/active_interaction/base_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe ActiveInteraction::Base do
+  let(:options) { {} }
+  subject(:interaction) { described_class.new(options) }
+
+  class InteractionWithAttribute < described_class
+    attr_reader :thing
+
+    validates :thing, presence: true
+
+    def execute
+      thing
+    end
+  end
+
+  class InteractionWithFilter < described_class
+    float :thing
+
+    def execute
+      thing
+    end
+  end
+
+  class InteractionWithFilters < described_class
+    float :thing1, :thing2
+
+    def execute; end
+  end
+
+  describe '.new(options = {})' do
+    it 'does not allow :result as an option' do
+      options.merge!(result: nil)
+      expect { interaction }.to raise_error ArgumentError
+    end
+
+    it 'does not allow "result" as an option' do
+      options.merge!('result' => nil)
+      expect { interaction }.to raise_error ArgumentError
+    end
+
+    describe InteractionWithAttribute do
+      let(:described_class) { InteractionWithAttribute }
+      let(:thing) { SecureRandom.hex }
+
+      context 'failing validations' do
+        before { options.merge!(thing: nil) }
+
+        it 'returns an invalid outcome' do
+          expect(interaction).to be_invalid
+        end
+      end
+
+      context 'passing validations' do
+        before { options.merge!(thing: thing) }
+
+        it 'returns a valid outcome' do
+          expect(interaction).to be_valid
+        end
+
+        it 'sets the attribute' do
+          expect(interaction.thing).to eq thing
+        end
+      end
+    end
+  end
+
+  describe '.method_missing(filter_type, *args, &block)' do
+    it 'raises an error for invalid filter types' do
+      expect {
+        class InteractionWithInvalidFilter < described_class
+          not_a_valid_filter_type :thing
+          def execute; end
+        end
+      }.to raise_error NoMethodError
+    end
+
+    describe InteractionWithFilter do
+      let(:described_class) { InteractionWithFilter }
+
+      it 'adds an attr_reader' do
+        expect(interaction).to respond_to :thing
+      end
+
+      it 'adds an attr_writer' do
+        expect(interaction).to respond_to :thing=
+      end
+    end
+
+    describe InteractionWithFilters do
+      let(:described_class) { InteractionWithFilters }
+
+      %w(thing1 thing2).each do |thing|
+        it "adds an attr_reader for #{thing}" do
+          expect(interaction).to respond_to thing
+        end
+
+        it "adds an attr_writer for #{thing}" do
+          expect(interaction).to respond_to "#{thing}="
+        end
+      end
+    end
+  end
+
+  describe InteractionWithFilter do
+    let(:described_class) { InteractionWithFilter }
+    let(:thing) { rand }
+
+    describe '.run(options = {})' do
+      subject(:outcome) { described_class.run(options) }
+
+      it "returns an instance of #{described_class}" do
+        expect(outcome).to be_a described_class
+      end
+
+      context 'failing validations' do
+        it 'returns an invalid outcome' do
+          expect(outcome).to be_invalid
+        end
+
+        it 'sets the result to nil' do
+          expect(outcome.result).to be_nil
+        end
+      end
+
+      context 'passing validations' do
+        before { options.merge!(thing: thing) }
+
+        it 'returns a valid outcome' do
+          expect(outcome).to be_valid
+        end
+
+        it 'sets the result' do
+          expect(outcome.result).to eq thing
+        end
+      end
+    end
+
+    describe '.run!(options = {})' do
+      subject(:result) { described_class.run!(options) }
+
+      context 'failing validations' do
+        it 'raises an error' do
+          expect { result }.to raise_error ActiveInteraction::InteractionInvalid
+        end
+      end
+
+      context 'passing validations' do
+        before { options.merge!(thing: thing) }
+
+        it 'returns the result' do
+          expect(result).to eq thing
+        end
+      end
+    end
+  end
+
+  describe '#execute' do
+    it 'raises an error' do
+      expect { interaction.execute }.to raise_error NotImplementedError
+    end
+  end
+
+  describe '#new_record?' do
+    it 'returns true' do
+      expect(interaction).to be_new_record
+    end
+  end
+
+  describe '#persisted?' do
+    it 'returns false' do
+      expect(interaction).to_not be_persisted
+    end
+  end
+end

data/spec/active_interaction/filter_method_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe ActiveInteraction::FilterMethod do
+  describe '.new(method_name, *args, &block)' do
+    let(:method_name) { SecureRandom.hex }
+    let(:attribute) { nil }
+    let(:options) { {} }
+    let(:args) { [] }
+    let(:block) { nil }
+    subject(:filter_method) { described_class.new(method_name, *args, &block) }
+
+    shared_examples 'instance variable assignment' do
+      its(:method_name) { should equal method_name }
+      its(:attribute) { should equal attribute }
+      its(:options) { should eq options }
+      its(:block) { should equal block }
+    end
+
+    include_examples 'instance variable assignment'
+
+    context 'with an attribute' do
+      let(:attribute) { SecureRandom.hex.to_sym }
+
+      before { args << attribute }
+
+      include_examples 'instance variable assignment'
+    end
+
+    context 'with options' do
+      let(:options) { { nil => nil } }
+
+      before { args << options }
+
+      include_examples 'instance variable assignment'
+
+      it 'does not allow :default' do
+        options.merge!(default: nil)
+        expect { filter_method }.to raise_error ArgumentError
+      end
+    end
+
+    context 'with a block' do
+      let(:block) { Proc.new {} }
+
+      include_examples 'instance variable assignment'
+    end
+  end
+end

data/spec/active_interaction/filter_methods_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ActiveInteraction::FilterMethods do
+  let(:block) { Proc.new {} }
+  subject(:filter_methods) { described_class.evaluate(&block) }
+
+  describe '.evaluate(&block)' do
+    it "returns an instance of #{described_class}" do
+      expect(filter_methods).to be_a described_class
+    end
+
+    it 'does not add any filter methods' do
+      expect(filter_methods.count).to eq 0
+    end
+
+    context 'with a filter method' do
+      let(:block) { Proc.new { boolean } }
+
+      it 'adds a filter method' do
+        expect(filter_methods.count).to eq 1
+      end
+    end
+  end
+
+  describe '#each' do
+    it 'returns an Enumerator' do
+      expect(filter_methods.each).to be_an Enumerator
+    end
+  end
+end

data/spec/active_interaction/filter_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module ActiveInteraction
+  class TestFilter < Filter; end
+end
+
+describe ActiveInteraction::Filter do
+  it_behaves_like 'a filter'
+
+  describe '.factory(type)' do
+    let(:result) { described_class.factory(type) }
+
+    context 'with a valid type' do
+      let(:type) { :test }
+
+      it 'returns the Class' do
+        expect(result).to eql ActiveInteraction::TestFilter
+      end
+    end
+
+    context 'with an invalid type' do
+      let(:type) { :not_a_valid_type }
+
+      it 'raises an error' do
+        expect { result }.to raise_error NoMethodError
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/array_filter_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe ActiveInteraction::ArrayFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with an Array' do
+      let(:value) { [] }
+
+      it 'returns the Array' do
+        expect(result).to eql value
+      end
+    end
+
+    context 'with block as a valid block' do
+      let(:block) { Proc.new { array } }
+
+      context 'with an Array of Arrays' do
+        let(:value) { [[]] }
+
+        it 'returns the Array' do
+          expect(result).to eql value
+        end
+      end
+
+      context 'with an Array of anything else' do
+        let(:value) { [Object.new] }
+
+        it 'raises an error' do
+          expect { result }.to raise_error ActiveInteraction::InvalidValue
+        end
+      end
+    end
+
+    context 'with block as a nested block' do
+      let(:block) { Proc.new { array { array } } }
+      let(:value) { [[[]]] }
+
+      it 'returns the Array' do
+        expect(result).to eql value
+      end
+    end
+
+    context 'with block as an invalid block' do
+      let(:block) { Proc.new { array; array } }
+      let(:value) { [] }
+
+      it 'raises an error' do
+        expect { result }.to raise_error ArgumentError
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/boolean_filter_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe ActiveInteraction::BooleanFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with true' do
+      let(:value) { true }
+
+      it 'returns true' do
+        expect(result).to eql true
+      end
+    end
+
+    context 'with false' do
+      let(:value) { false }
+
+      it 'returns false' do
+        expect(result).to eql false
+      end
+    end
+
+    context 'with "1"' do
+      let(:value) { '1' }
+
+      it 'returns true' do
+        expect(result).to eql true
+      end
+    end
+
+    context 'with "0"' do
+      let(:value) { '0' }
+
+      it 'returns false' do
+        expect(result).to eql false
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/date_filter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ActiveInteraction::DateFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with a Date' do
+      let(:value) { Date.today }
+
+      it 'returns the Date' do
+        expect(result).to eql value
+      end
+    end
+
+    context 'with a valid String' do
+      let(:value) { '2001-01-01' }
+
+      it 'parses the String' do
+        expect(result).to eql Date.parse(value)
+      end
+    end
+
+    context 'with an invalid String' do
+      let(:value) { 'not a valid Date' }
+
+      it 'raises an error' do
+        expect { result }.to raise_error ActiveInteraction::InvalidValue
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/date_time_filter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ActiveInteraction::DateTimeFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with a DateTime' do
+      let(:value) { DateTime.now }
+
+      it 'returns the DateTime' do
+        expect(result).to eql value
+      end
+    end
+
+    context 'with a valid String' do
+      let(:value) { '2001-01-01T01:01:01+01:01' }
+
+      it 'parses the String' do
+        expect(result).to eql DateTime.parse(value)
+      end
+    end
+
+    context 'with an invalid String' do
+      let(:value) { 'not a valid DateTine' }
+
+      it 'raises an error' do
+        expect { result }.to raise_error ActiveInteraction::InvalidValue
+      end
+    end
+  end
+end