HornsAndHooves-flat_map 0.2.0

data/spec/flat_map/mapper/targeting_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+module FlatMap
+  module ModelMethodsSpec
+    class TargetClass < Struct.new(:attr_a, :attr_b)
+    end
+
+    class OtherTargetClass < Struct.new(:attr_c, :attr_d)
+    end
+
+    module ArbitraryModule
+    end
+
+    class TargetClassMapper < Mapper
+      include ArbitraryModule
+
+      map :attr_a
+      map :dob => :attr_b, :multiparam => Date
+    end
+
+    class InheritedClassMapper < TargetClassMapper
+    end
+
+    class ExplicitNameMapper < Mapper
+      self.target_class_name = 'FlatMap::ModelMethodsSpec::OtherTargetClass'
+    end
+  end
+
+  describe 'Working with Target' do
+    describe '#target_class' do
+      it 'should detect target_class from mapper class name' do
+        ModelMethodsSpec::TargetClassMapper.target_class.should == ModelMethodsSpec::TargetClass
+      end
+
+      it 'should detect target_class from nearest ancestor when inherited' do
+        ModelMethodsSpec::InheritedClassMapper.target_class.
+                                               should == ModelMethodsSpec::TargetClass
+      end
+
+      it 'should use explicit class name if specified' do
+        ModelMethodsSpec::ExplicitNameMapper.target_class.
+                                             should == ModelMethodsSpec::OtherTargetClass
+      end
+    end
+
+    describe '.build' do
+      it 'should use target class to build a new object for mapper' do
+        ModelMethodsSpec::TargetClassMapper.
+          should_receive(:new).
+          with(kind_of(ModelMethodsSpec::TargetClass), :used_trait)
+        ModelMethodsSpec::TargetClassMapper.build(:used_trait)
+      end
+    end
+
+    describe '.find' do
+      let(:target){ ModelMethodsSpec::TargetClass.new('a', 'b') }
+
+      it 'should delegate to target class to find object for mapper' do
+        ModelMethodsSpec::TargetClass.should_receive(:find).with(1).and_return(target)
+        ModelMethodsSpec::TargetClassMapper.should_receive(:new).with(target, :used_trait)
+        ModelMethodsSpec::TargetClassMapper.find(1, :used_trait)
+      end
+    end
+
+    describe 'behavior' do
+      let(:target){ ModelMethodsSpec::TargetClass.new('a', 'b') }
+      let(:mapper){ ModelMethodsSpec::TargetClassMapper.new(target){} }
+
+      specify '#model_name' do
+        mapper.model_name.should == 'mapper'
+      end
+
+      specify '#to_key should delegate to target' do
+        target.should_receive(:to_key).and_return(1)
+        mapper.to_key.should == 1
+      end
+
+      specify '#persisted? when target does not respond to :persised?' do
+        mapper.should_not be_persisted
+      end
+
+      specify '#persisted? when target responds to :persisted?' do
+        target.stub(:persisted?).and_return(true)
+        mapper.should be_persisted
+      end
+
+      specify '#id when target does not respond to :id' do
+        mapper.id.should be_nil
+      end
+
+      specify '#id when target responds to :id' do
+        target.stub(:id).and_return(1)
+        mapper.id.should == 1
+      end
+
+      describe '#write with multiparams' do
+        let(:params) {{
+          'attr_a'     => 'A',
+          'dob(0i)' => '1999',
+          'dob(1i)' => '01',
+          'dob(2i)' => '02'
+        }}
+
+        it 'should assign values properly' do
+          mapper.write(params)
+          target.attr_a.should == 'A'
+          target.attr_b.should == Date.new(1999, 1, 2)
+        end
+      end
+
+      describe '#save_target' do
+        it 'should return true for owned mappers' do
+          mapper.extension.save_target.should be true
+        end
+
+        it 'should return true if target does not respond to #save' do
+          mapper.save_target.should be true
+        end
+
+        it 'should save with no validation if target responds to #save' do
+          target.should_receive(:save).with(:validate => false).and_return(true)
+          mapper.save_target.should be true
+        end
+      end
+
+      describe '#apply' do
+        let(:params){{ :attr_a => 'A' }}
+
+        it 'should write params first' do
+          mapper.should_receive(:write).with(params)
+          ActiveRecord::Base.should_receive(:transaction).and_yield
+          mapper.apply(params)
+        end
+
+        it 'should not save if not valid' do
+          mapper.stub(:valid?).and_return(false)
+          mapper.should_not_receive(:save)
+          mapper.apply(params)
+        end
+
+        it 'should save if valid' do
+          mapper.stub(:valid?).and_return(true)
+          ActiveRecord::Base.should_receive(:transaction).and_yield
+          mapper.should_receive(:save)
+          mapper.apply(params)
+        end
+      end
+
+      specify '#shallow_save saves target in a save callbacks' do
+        mapper.should_receive(:run_callbacks).with(:save).and_yield
+        mapper.should_receive(:save_target)
+        mapper.shallow_save
+      end
+    end
+  end
+end

data/spec/flat_map/mapper/traits_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+module FlatMap
+  module TraitsSpec
+    TargetClass = Struct.new(:attr_a, :attr_b)
+    MountClass  = Struct.new(:attr_c, :attr_d)
+
+    class HostMapper < Mapper
+      map :attr_a
+
+      trait :trait_one do
+        map :attr_b
+
+        mount :spec_mount,
+          :mapper_class_name => 'FlatMap::TraitsSpec::MountMapper',
+          :target => lambda{ |_| TraitsSpec.mount_target }
+
+        def method_one
+          'one'
+        end
+
+        trait :trait_one_nested do
+          def method_one_nested
+            'nested_one'
+          end
+        end
+      end
+
+      trait :trait_two do
+        def method_two
+          method_one
+        end
+      end
+    end
+
+    class MountMapper < Mapper
+      map :attr_c, :attr_d
+    end
+
+    class EmptyMapper < Mapper; end
+
+    def self.mount_target
+      @mount_target ||= MountClass.new('c', 'd')
+    end
+
+    def self.reset_mount_target
+      @mount_target = nil
+    end
+  end
+
+  describe 'Traits' do
+    describe 'trait definition' do
+      it "should add a traited mapper factory to a class" do
+        TraitsSpec::EmptyMapper.should_receive(:mount).
+                                with(kind_of(Class), :trait_name => :a_trait).
+                                and_call_original
+        expect{ TraitsSpec::EmptyMapper.trait(:a_trait) }.
+          to change{ TraitsSpec::EmptyMapper.mountings.length }.by(1)
+        trait_mapper_class =
+          TraitsSpec::EmptyMapper.mountings.first.instance_variable_get('@identifier')
+        trait_mapper_class.name.should == 'FlatMap::TraitsSpec::EmptyMapperATraitTrait'
+      end
+    end
+
+    describe 'trait usage' do
+      let(:target){ TraitsSpec::TargetClass.new('a', 'b') }
+      let(:mount_target){ TraitsSpec.mount_target }
+      let(:mapper){ TraitsSpec::HostMapper.new(target, :trait_one) }
+      let(:trait){ mapper.trait(:trait_one) }
+
+      after{ TraitsSpec.reset_mount_target }
+
+      describe 'trait properties' do
+        subject{ trait }
+
+        it{ should_not be_extension }
+        it{ should be_owned }
+        its(:owner){ should == mapper }
+      end
+
+      it 'should be able to access trait by name' do
+        mapper.trait(:trait_one).should be_a(Mapper)
+        mapper.trait(:undefined).should be_nil
+      end
+
+      it 'should not contain unused trait' do
+        mapper.trait(:trait_two).should be_nil
+      end
+
+      it 'should have mountings of a trait' do
+        mapper.mounting(:spec_mount).should be_present
+      end
+
+      it '#read should read values with respect to trait' do
+        mapper.read.should == {
+          :attr_a => 'a',
+          :attr_b => 'b',
+          :attr_c => 'c',
+          :attr_d => 'd'
+        }
+      end
+
+      it '#write should properly distribute values' do
+        mapper.write \
+          :attr_a => 'A',
+          :attr_b => 'B',
+          :attr_c => 'C',
+          :attr_d => 'D'
+        target.attr_a.should == 'A'
+        target.attr_b.should == 'B'
+        mount_target.attr_c.should == 'C'
+        mount_target.attr_d.should == 'D'
+      end
+
+      specify 'mapper should be avle to call methods of enabled traits' do
+        mapper = TraitsSpec::HostMapper.new(target, :trait_one)
+        mapper.method_one.should == 'one'
+        expect{ mapper.method_two }.to raise_error(NoMethodError)
+      end
+
+      specify 'traits should be able to call methods of each other' do
+        mapper = TraitsSpec::HostMapper.new(target, :trait_one, :trait_two)
+        mapper.trait(:trait_two).method_two.should == 'one'
+      end
+
+      describe 'trait nesting' do
+        let(:mapper){ TraitsSpec::HostMapper.new(target, :trait_one_nested) }
+
+        it 'should still be able to have top-level trait definitions' do
+          mapper.mounting(:spec_mount).should be_present
+          mapper.method_one.should == 'one'
+        end
+
+        it 'should have new definitions' do
+          mapper.method_one_nested.should == 'nested_one'
+        end
+      end
+
+      describe 'extension trait' do
+        let(:mapper) do
+          TraitsSpec::HostMapper.new(target) do
+            map :attr_b
+
+            def writing_error=(value)
+              raise ArgumentError, 'cannot be foo' if value == 'foo'
+            rescue ArgumentError => e
+              errors.preserve :writing_error, e.message
+            end
+          end
+        end
+
+        it 'should behave like a normal trait' do
+          mapper.trait(:extension).should be_present
+          mapper.read.should include :attr_b => 'b'
+        end
+
+        it 'should be accessible' do
+          mapper.extension.should be_present
+        end
+
+        it 'should be_extension' do
+          mapper.extension.should be_extension
+        end
+
+        it "should be able to handle save exception of traits" do
+          expect{ mapper.apply(:writing_error => 'foo') }.not_to raise_error
+          mapper.errors[:writing_error].should include 'cannot be foo'
+        end
+      end
+    end
+  end
+end

data/spec/flat_map/mapper/validations_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+class SpecFooValidator < ActiveModel::EachValidator
+  def validate_each(object, attribute, value)
+    object.errors.add(attribute, "can't be foo") if value == "foo"
+  end
+end
+
+module FlatMap
+  module ValidationsSpec
+    class TargetClass < Struct.new(:attr_a, :attr_b, :attr_c)
+    end
+
+    class MountTargetClass < Struct.new(:attr_d)
+    end
+
+    class MountMapper < Mapper
+      map :attr_d
+
+      validates :attr_d, :presence => true
+    end
+
+    class HostMapper < Mapper
+      map :attr_a
+
+      validates_presence_of :attr_a
+
+      trait :with_trait do
+        map :attr_b
+
+        validates :attr_b, :spec_foo => true
+
+        set_callback :validate, :before, :set_default_attr_b, :prepend => true
+
+        def set_default_attr_b
+          self.attr_b = 'foo' if attr_b.blank?
+        end
+      end
+
+      mount :mounted,
+        :target            => lambda{ |_| ValidationsSpec::MountTargetClass.new },
+        :mapper_class_name => 'FlatMap::ValidationsSpec::MountMapper'
+    end
+  end
+
+  describe 'Validations' do
+    let(:mapper) do
+      ValidationsSpec::HostMapper.new(ValidationsSpec::TargetClass.new, :with_trait) do
+        map :attr_c
+        validates_presence_of :attr_c
+      end
+    end
+
+    it 'should not be valid' do
+      mapper.should_not be_valid
+    end
+
+    it 'should call callbacks' do
+      mapper.trait(:with_trait).should_receive(:set_default_attr_b).and_call_original
+      mapper.valid?
+      mapper.attr_b.should == 'foo'
+    end
+
+    it 'should have all the errors' do
+      mapper.valid?
+      mapper.errors[:attr_a].should == ["can't be blank"]
+      mapper.errors[:attr_b].should == ["can't be foo"]
+      mapper.errors[:attr_c].should == ["can't be blank"]
+      mapper.errors[:attr_d].should == ["can't be blank"]
+    end
+  end
+end

data/spec/flat_map/mapper_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module FlatMap
+  describe Mapper do
+    # Place some complex behavior specs here.
+    # All specs responsible for basic modular behavior
+    # are located under spec/flat_map/mapper.
+  end
+end

data/spec/flat_map/mapping/factory_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Factory do
+  let(:factory){ described_class.new(:foo, :bar, :baz) }
+
+  specify('#create should delegate all initialization params to new mapping') do
+    mapper_stub = double('mapper')
+    FlatMap::Mapping.should_receive(:new).with(mapper_stub, :foo, :bar, :baz)
+
+    factory.create(mapper_stub)
+  end
+end

data/spec/flat_map/mapping/reader/basic_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Reader::Basic do
+  let(:target){ double('target') }
+  let(:mapping){ double('mapping') }
+  let(:reader){ described_class.new(mapping) }
+
+  specify("#read should fetch value from mapping's target_attribute") do
+    mapping.should_receive(:target).and_return(target)
+    mapping.should_receive(:target_attribute).and_return(:foo)
+    target.should_receive(:foo).and_return(:bar)
+
+    reader.read.should == :bar
+  end
+end

data/spec/flat_map/mapping/reader/formatted_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe FlatMap::Mapping::Reader::Formatted do
+  let(:value){ 'fOoBaR' }
+  let(:target){ double('target', :attr => value) }
+  let(:mapping){ double('mapping', :target => target, :target_attribute => :attr) }
+
+  context 'generic behavior' do
+    let(:reader){ described_class.new(mapping, :spec_format).extend(spec_extension) }
+    let(:spec_extension) do
+      Module.new do
+        def spec_format(value, transformation = :upcase)
+          case transformation
+          when :upcase then value.upcase
+          when :downcase then value.downcase
+          else value
+          end
+        end
+      end
+    end
+
+    specify "#read should use formatting method for fetching a value" do
+      reader.read.should == 'FOOBAR'
+      reader.read(:downcase).should == 'foobar'
+      reader.read(:unknown).should == 'fOoBaR'
+    end
+  end
+
+  context 'default formats' do
+    describe "i18n_1" do
+      let(:reader){ described_class.new(mapping, :i18n_l) }
+
+      it "should use I18n_l to format value" do
+        formatted_value = "le FooBar"
+        I18n.should_receive(:l).with(value).and_return(formatted_value)
+
+        reader.read.should == formatted_value
+      end
+    end
+
+    describe "enum" do
+      unless defined? PowerEnum
+        module ::PowerEnum; end
+        load 'flat_map/mapping/reader/formatted/formats.rb'
+      end
+
+      let(:enum){ Object.new }
+      let(:target){ double('target', :attr => enum) }
+      let(:reader){ described_class.new(mapping, :enum) }
+
+      it "should use the name property of the target object for value" do
+        enum.should_receive(:name).and_return(value)
+        reader.read.should == value
+      end
+
+      it "should be able to use the desired method to get enum's property" do
+        enum.should_receive(:description).and_return(value)
+        reader.read(:description).should == value
+      end
+    end
+  end
+end