active_interaction 0.1.1

data/spec/active_interaction/filters/file_filter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ActiveInteraction::FileFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with a File' do
+      let(:value) { File.open(__FILE__) }
+
+      it 'returns the File' do
+        expect(result).to equal value
+      end
+    end
+
+    context 'with a Tempfile' do
+      let(:value) { Tempfile.new('temp') }
+
+      it 'returns the Tempfile' do
+        expect(result).to equal value
+      end
+    end
+
+    context 'with a object that responds to `tempfile`' do
+      let(:value) { double(tempfile: Tempfile.new('temp')) }
+
+      it 'returns the Tempfile' do
+        expect(result).to equal value.tempfile
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/float_filter_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe ActiveInteraction::FloatFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with a Float' do
+      let(:value) { rand }
+
+      it 'returns the Float' do
+        expect(result).to eql value
+      end
+    end
+
+    context 'with an Integer' do
+      let(:value) { rand(1 << 16) }
+
+      it 'converts the Integer' do
+        expect(result).to eql Float(value)
+      end
+    end
+
+    context 'with a valid String' do
+      let(:value) { rand.to_s }
+
+      it 'converts the String' do
+        expect(result).to eql Float(value)
+      end
+    end
+
+    context 'with an invalid String' do
+      let(:value) { 'not a valid Float' }
+
+      it 'raises an error' do
+        expect { result }.to raise_error ActiveInteraction::InvalidValue
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/hash_filter_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe ActiveInteraction::HashFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with a Hash' do
+      let(:value) { {} }
+
+      it 'returns the Hash' do
+        expect(result).to eql value
+      end
+    end
+
+    context 'with block as a block' do
+      let(:block) { Proc.new { hash :a } }
+
+      context 'with a Hash containing a Hash' do
+        let(:value) { { a: {} } }
+
+        it 'returns the Hash' do
+          expect(result).to eql value
+        end
+      end
+
+      context 'with a Hash containing anything else' do
+        let(:value) { { a: Object.new } }
+
+        it 'raises an error' do
+          expect { result }.to raise_error ActiveInteraction::InvalidValue
+        end
+      end
+    end
+
+    context 'with block as a block with multiple filters' do
+      let(:block) { Proc.new { hash :a; hash :b } }
+
+      context 'with a Hash containing Hashes' do
+        let(:value) { { a: {}, b: {} } }
+
+        it 'returns the Hash' do
+          expect(result).to eql value
+        end
+      end
+    end
+
+    context 'with block as a nested block' do
+      let(:block) { Proc.new { hash :a do; hash :b end } }
+      let(:value) { { a: { b: {} } } }
+
+      it 'returns the Hash' do
+        expect(result).to eql value
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/integer_filter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe ActiveInteraction::IntegerFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with an Integer' do
+      let(:value) { rand(1 << 16) }
+
+      it 'returns the Integer' do
+        expect(result).to eql value
+      end
+    end
+
+    context 'with a valid String' do
+      let(:value) { rand(1 << 16).to_s }
+
+      it 'converts the String' do
+        expect(result).to eql Integer(value)
+      end
+    end
+
+    context 'with an invalid String' do
+      let(:value) { 'not a valid Integer' }
+
+      it 'raises an error' do
+        expect { result }.to raise_error ActiveInteraction::InvalidValue
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/model_filter_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+TestModel = Class.new
+
+describe ActiveInteraction::ModelFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  before { options.merge!(class: TestModel) }
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    shared_examples 'typechecking' do
+      context 'with the right class' do
+        let(:value) { TestModel.new }
+
+        it 'returns the instance' do
+          expect(result).to eql value
+        end
+      end
+    end
+
+    context 'with options[:class] as a Class' do
+      include_examples 'typechecking'
+    end
+
+    context 'with options[:class] as a valid String' do
+      include_examples 'typechecking'
+
+      before { options.merge!(class: options[:class].to_s) }
+    end
+
+    context 'with options[:class] as an invalid String' do
+      before { options.merge!(class: 'not a valid Class') }
+
+      it 'raises an error' do
+        expect { result }.to raise_error NameError
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/string_filter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ActiveInteraction::StringFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with a String' do
+      let(:value) { SecureRandom.hex }
+
+      it 'returns the String' do
+        expect(result).to eql value
+      end
+    end
+  end
+end

data/spec/active_interaction/filters/time_filter_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe ActiveInteraction::TimeFilter do
+  include_context 'filters'
+  it_behaves_like 'a filter'
+
+  describe '.prepare(key, value, options = {}, &block)' do
+    context 'with a Time' do
+      let(:value) { Time.now }
+
+      it 'returns the Time' do
+        expect(result).to eql value
+      end
+    end
+
+    shared_examples 'conversion' do
+      context 'with a float' do
+        let(:value) { rand }
+
+        it 'converts the Float' do
+          expect(result).to eql Time.at(value)
+        end
+      end
+
+      context 'with an Integer' do
+        let(:value) { rand(1 << 16) }
+
+        it 'converts the Integer' do
+          expect(result).to eql Time.at(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 Time.parse(value)
+        end
+      end
+
+      context 'with an invalid String' do
+        let(:value) { 'not a valid Time' }
+
+        it 'raises an error' do
+          expect { result }.to raise_error ActiveInteraction::InvalidValue
+        end
+      end
+    end
+
+    context 'without Time.zone' do
+      include_examples 'conversion'
+    end
+
+    context 'with Time.zone' do
+      include_examples 'conversion'
+
+      before do
+        allow(Time).to receive(:zone).and_return(Time)
+      end
+
+      after do
+        expect(Time).to have_received(:zone).with(no_args)
+      end
+    end
+  end
+end

data/spec/active_interaction/integration/array_interaction_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+class ArrayInteraction < ActiveInteraction::Base
+  array :a do
+    array
+  end
+  array :b, default: [[]] do
+    array
+  end
+
+  def execute
+    { a: a, b: b }
+  end
+end
+
+describe ArrayInteraction do
+  include_context 'interactions'
+  it_behaves_like 'an interaction', :array, -> { [] }
+
+  context 'with options[:a]' do
+    let(:a) { [[]] }
+
+    before { options.merge!(a: a) }
+
+    it 'returns the correct value for :a' do
+      expect(result[:a]).to eq a
+    end
+
+    it 'returns the correct value for :b' do
+      expect(result[:b]).to eq [[]]
+    end
+  end
+
+  context 'with an invalid default' do
+    it 'raises an error' do
+      expect {
+        Class.new(ActiveInteraction::Base) do
+          array :a, default: Object.new
+        end
+      }.to raise_error ActiveInteraction::InvalidDefaultValue
+    end
+  end
+
+  context 'with an invalid nested default' do
+    it 'raises an error' do
+      expect {
+        Class.new(ActiveInteraction::Base) do
+          array :a, default: [Object.new] do
+            array
+          end
+        end
+      }.to raise_error ActiveInteraction::InvalidDefaultValue
+    end
+  end
+
+  context 'with an invalidly nested default' do
+    it 'raises an error' do
+      expect {
+        klass = Class.new(ActiveInteraction::Base) do
+          array :a do
+            array default: []
+          end
+        end
+        # TODO: We should fail when defining the class, not when trying to run it.
+        klass.run(a: [])
+      }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/active_interaction/integration/boolean_interaction_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'BooleanInteraction' do
+  it_behaves_like 'an interaction', :boolean, -> { [false, true].sample }
+end

data/spec/active_interaction/integration/date_interaction_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'DateInteraction' do
+  it_behaves_like 'an interaction', :date, -> { Date.today }
+end

data/spec/active_interaction/integration/date_time_interaction_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'DateTimeInteraction' do
+  it_behaves_like 'an interaction', :date_time, -> { DateTime.now }
+end

data/spec/active_interaction/integration/file_interaction_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'FileInteraction' do
+  it_behaves_like 'an interaction', :file, -> { File.open(__FILE__) }
+end

data/spec/active_interaction/integration/float_interaction_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'FloatInteraction' do
+  it_behaves_like 'an interaction', :float, -> { rand }
+end

data/spec/active_interaction/integration/hash_interaction_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+class HashInteraction < ActiveInteraction::Base
+  hash :a do
+    hash :x
+  end
+  hash :b, default: { x: {} } do
+    hash :x
+  end
+
+  def execute
+    { a: a, b: b }
+  end
+end
+
+describe HashInteraction do
+  include_context 'interactions'
+  it_behaves_like 'an interaction', :hash, -> { {} }
+
+  context 'with options[:a]' do
+    let(:a) { { 'x' => {} } }
+
+    before { options.merge!(a: a) }
+
+    it 'returns the correct value for :a' do
+      expect(result[:a]).to eq a
+    end
+
+    it 'returns the correct value for :b' do
+      expect(result[:b]).to eq(x: {})
+    end
+  end
+
+  context 'with an invalid default' do
+    it 'raises an error' do
+      expect {
+        Class.new(ActiveInteraction::Base) do
+          hash :a, default: Object.new
+        end
+      }.to raise_error ActiveInteraction::InvalidDefaultValue
+    end
+  end
+
+  context 'with an invalid nested default' do
+    it 'raises an error' do
+      expect {
+        Class.new(ActiveInteraction::Base) do
+          hash :a, default: { x: Object.new } do
+            hash :x
+          end
+        end
+      }.to raise_error ActiveInteraction::InvalidDefaultValue
+    end
+  end
+
+  context 'with an invalidly nested default' do
+    it 'raises an error' do
+      expect {
+        klass = Class.new(ActiveInteraction::Base) do
+          hash :a do
+            hash :x, default: {}
+          end
+        end
+        # TODO: We should fail when defining the class, not when trying to run it.
+        klass.run(a: {})
+      }.to raise_error ArgumentError
+    end
+  end
+end