mark_mapper 0.0.1

data/spec/symbol_operator_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe SymbolOperator do
+  context "SymbolOperator" do
+    before  { @operator = SymbolOperator.new(:foo, 'eq') }
+    subject { @operator }
+
+    it "has field" do
+      subject.field.should == :foo
+    end
+
+    it "has operator" do
+      subject.operator.should == 'eq'
+    end
+
+    context "==" do
+      it "returns true if field and operator are equal" do
+        SymbolOperator.new(:foo, 'eq').should == SymbolOperator.new(:foo, 'eq')
+      end
+
+      it "returns false if fields are equal but operators are not" do
+        SymbolOperator.new(:foo, 'eq').should_not == SymbolOperator.new(:foo, 'all')
+      end
+
+      it "returns false if operators are equal but fields are not" do
+        SymbolOperator.new(:foo, 'eq').should_not == SymbolOperator.new(:bar, 'eq')
+      end
+
+      it "returns false if neither are equal" do
+        SymbolOperator.new(:foo, 'eq').should_not == SymbolOperator.new(:bar, 'all')
+      end
+
+      it "returns false if other isn't an symbol operator" do
+        SymbolOperator.new(:foo, 'eq').should_not == 'foo.in'
+      end
+    end
+
+    context "hash" do
+
+      it 'returns sum of operator and hash field' do
+        SymbolOperator.new(:foo, 'eq').hash.should == :foo.hash + 'eq'.hash
+      end
+
+    end
+
+    context 'eql?' do
+
+      it 'uses #== for equality comparison' do
+        expect(subject).to receive(:"==").with("dummy_value")
+        subject.eql?("dummy_value")
+      end
+
+    end
+
+    context "<=>" do
+      it "returns string comparison of operator for same field, different operator" do
+        (SymbolOperator.new(:foo, 'eq') <=> SymbolOperator.new(:foo, 'all')).should ==  1
+        (SymbolOperator.new(:foo, 'all') <=> SymbolOperator.new(:foo, 'eq')).should == -1
+      end
+
+      it "returns 0 for same field same operator" do
+        (SymbolOperator.new(:foo, 'eq') <=> SymbolOperator.new(:foo, 'eq')).should == 0
+      end
+
+      it "returns 1 for different field" do
+        (SymbolOperator.new(:foo, 'eq') <=> SymbolOperator.new(:bar, 'eq')).should == 1
+      end
+    end
+  end
+end

data/spec/symbol_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Symbol do
+  SymbolOperators.each do |operator|
+    it "responds to #{operator}" do
+      :foo.send(operator).should be_instance_of(SymbolOperator)
+    end
+  end
+end

data/spec/unit/associations/base_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+class FooMonster; end
+module AssociationSpec
+  include MarkMapper::Plugins::Associations
+
+  describe MarkMapper::Plugins::Associations::Base do
+    it "should initialize with type and name" do
+      base = ManyAssociation.new(:foos)
+      base.name.should == :foos
+    end
+
+    it "should also allow options when initializing" do
+      base = ManyAssociation.new(:foos, :polymorphic => true)
+      base.options[:polymorphic].should be_truthy
+    end
+
+    context "klass" do
+      it "should default to class_name constantized" do
+        BelongsToAssociation.new(:foo_monster).klass.should == FooMonster
+      end
+
+      it "should be the specified class" do
+        anonnymous_class = Class.new
+        BelongsToAssociation.new(:foo_monster, :class => anonnymous_class).klass.should == anonnymous_class
+      end
+    end
+
+    context "polymorphic?" do
+      it "should be true if polymorphic" do
+        ManyAssociation.new(:foos, :polymorphic => true).polymorphic?.should be_truthy
+      end
+
+      it "should be false if not polymorphic" do
+        ManyAssociation.new(:bars).polymorphic?.should be_falsey
+      end
+    end
+
+    context "as?" do
+      it "should be true if one" do
+        OneAssociation.new(:foo, :as => :commentable).as?.should be_truthy
+      end
+
+      it "should be false if not one" do
+        ManyAssociation.new(:foo).as?.should be_falsey
+      end
+    end
+
+    context "in_array?" do
+      it "should be true if one" do
+        OneAssociation.new(:foo, :in => :list_ids).in_array?.should be_truthy
+      end
+
+      it "should be false if not one" do
+        ManyAssociation.new(:foo).in_array?.should be_falsey
+      end
+    end
+
+    context "query_options" do
+      it "should default to empty hash" do
+        base = ManyAssociation.new(:foos)
+        base.query_options.should == {}
+      end
+
+      it "should work with order" do
+        base = ManyAssociation.new(:foos, :order => 'position')
+        base.query_options.should == {:order => 'position'}
+      end
+
+      it "should correctly parse from options" do
+        base = ManyAssociation.new(:foos, :order => 'position', :somekey => 'somevalue')
+        base.query_options.should == {:order => 'position', :somekey => 'somevalue'}
+      end
+    end
+
+    context "type_key_name" do
+      it "should be association name _ type for belongs_to" do
+        BelongsToAssociation.new(:foo).type_key_name.should == 'foo_type'
+      end
+    end
+
+    context "foreign_key" do
+      it "should default to assocation name _id for belongs to" do
+        base = BelongsToAssociation.new(:foo)
+        base.foreign_key.should == 'foo_id'
+      end
+
+      it "should be overridable with :foreign_key option" do
+        base = BelongsToAssociation.new(:foo, :foreign_key => 'foobar_id')
+        base.foreign_key.should == 'foobar_id'
+      end
+    end
+
+    it "should have ivar that is association name" do
+      BelongsToAssociation.new(:foo).ivar.should == '@_foo'
+    end
+
+    context "embeddable?" do
+      it "should be true if class is embeddable" do
+        base = ManyAssociation.new(:medias)
+        base.embeddable?.should be_truthy
+      end
+
+      it "should be false if class is not embeddable" do
+        base = ManyAssociation.new(:statuses)
+        base.embeddable?.should be_falsey
+
+        base = BelongsToAssociation.new(:project)
+        base.embeddable?.should be_falsey
+      end
+    end
+
+    context "proxy_class" do
+      it "should be BelongsToProxy for belongs_to" do
+        base = BelongsToAssociation.new(:project)
+        base.proxy_class.should == BelongsToProxy
+      end
+
+      it "should be BelongsToPolymorphicProxy for polymorphic belongs_to" do
+        base = BelongsToAssociation.new(:target, :polymorphic => true)
+        base.proxy_class.should == BelongsToPolymorphicProxy
+      end
+
+      it "should be OneProxy for one" do
+        base = OneAssociation.new(:status, :polymorphic => true)
+        base.proxy_class.should == OneProxy
+      end
+
+      it "should be OneEmbeddedProxy for one embedded" do
+        base = OneAssociation.new(:media)
+        base.proxy_class.should == OneEmbeddedProxy
+      end
+    end
+
+    context "touch?" do
+      it "should be true if touch" do
+        BelongsToAssociation.new(:car, :touch => true).touch?.should be_truthy
+      end
+
+      it "should be false if not touch" do
+        BelongsToAssociation.new(:car).touch?.should be_falsey
+      end
+    end
+
+  end
+end

data/spec/unit/associations/belongs_to_association_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module BelongsToAssociation
+  include MarkMapper::Plugins::Associations
+  describe "BelongsToAssociation" do
+
+    context "class_name" do
+      it "should camelize the name" do
+        BelongsToAssociation.new(:user).class_name.should == 'User'
+      end
+
+      it "should be changeable using class_name option" do
+        association = BelongsToAssociation.new(:user, :class_name => 'Person')
+        association.class_name.should == 'Person'
+      end
+    end
+
+    context "embeddable?" do
+      it "should be false even if class is embeddable" do
+        base = BelongsToAssociation.new(:address)
+        base.embeddable?.should be_falsey
+      end
+
+      it "should be false if class is not embeddable" do
+        base = BelongsToAssociation.new(:project)
+        base.embeddable?.should be_falsey
+      end
+    end
+  end
+end

data/spec/unit/associations/many_association_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+
+module ManyAssociationSpec
+  include MarkMapper::Plugins::Associations
+  describe "ManyAssociation" do
+
+    context "class_name" do
+      it "should camelize the name" do
+        ManyAssociation.new(:smart_people).class_name.should == 'SmartPerson'
+      end
+
+      it "should be changeable using class_name option" do
+        base = ManyAssociation.new(:smart_people, :class_name => 'IntelligentPerson')
+        base.class_name.should == 'IntelligentPerson'
+      end
+    end
+
+    context "type_key_name" do
+      it "should be _type" do
+        ManyAssociation.new(:foos).type_key_name.should == '_type'
+      end
+    end
+
+    context "embeddable?" do
+      it "should be true if class is embeddable" do
+        base = ManyAssociation.new(:medias)
+        base.embeddable?.should be_truthy
+      end
+
+      it "should be false if class is not embeddable" do
+        base = ManyAssociation.new(:statuses)
+        base.embeddable?.should be_falsey
+      end
+    end
+
+    context "proxy_class" do
+      it "should be ManyDocumentsProxy for many" do
+        base = ManyAssociation.new(:statuses)
+        base.proxy_class.should == ManyDocumentsProxy
+      end
+
+      it "should be ManyPolymorphicProxy for polymorphic many" do
+        base = ManyAssociation.new(:messages, :polymorphic => true)
+        base.proxy_class.should == ManyPolymorphicProxy
+      end
+
+      it "should be ManyEmbeddedProxy for many embedded" do
+        base = ManyAssociation.new(:medias)
+        base.proxy_class.should == ManyEmbeddedProxy
+      end
+
+      it "should be ManyEmbeddedPolymorphicProxy for polymorphic many embedded" do
+        base = ManyAssociation.new(:medias, :polymorphic => true)
+        base.proxy_class.should == ManyEmbeddedPolymorphicProxy
+      end
+
+      it "should be InArrayProxy for many with :in option" do
+        base = ManyAssociation.new(:messages, :in => :message_ids)
+        base.proxy_class.should == InArrayProxy
+      end
+    end
+  end
+end

data/spec/unit/associations/one_association_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+
+module OneAssociationSpec
+  include MarkMapper::Plugins::Associations
+  describe "OneAssociation" do
+
+    context "type_key_name" do
+      it "should be _type" do
+        OneAssociation.new(:foo).type_key_name.should == '_type'
+      end
+    end
+
+    context "embeddable?" do
+      it "should be true if class is embeddable" do
+        base = OneAssociation.new(:media)
+        base.embeddable?.should be_truthy
+      end
+
+      it "should be false if class is not embeddable" do
+        base = OneAssociation.new(:project)
+        base.embeddable?.should be_falsey
+      end
+    end
+
+    context "proxy_class" do
+      it "should be OneProxy for one" do
+        base = OneAssociation.new(:status)
+        base.proxy_class.should == OneProxy
+      end
+
+      it "should be OneAsProxy for one with :as option" do
+        base = OneAssociation.new(:message, :as => :messagable)
+        base.proxy_class.should == OneAsProxy
+      end
+
+      it "should be OneEmbeddedProxy for one embedded" do
+        base = OneAssociation.new(:media)
+        base.proxy_class.should == OneEmbeddedProxy
+      end
+
+      it "should be OneEmbeddedPolymorphicProxy for polymorphic one embedded" do
+        base = OneAssociation.new(:media, :polymorphic => true)
+        base.proxy_class.should == OneEmbeddedPolymorphicProxy
+      end
+    end
+  end
+end

data/spec/unit/associations/proxy_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+class FakeNilProxy < MarkMapper::Plugins::Associations::Proxy
+  def find_target; nil end
+end
+
+class FakeBlankProxy < MarkMapper::Plugins::Associations::Proxy
+  def find_target; '' end
+end
+
+class FakeNumberProxy < MarkMapper::Plugins::Associations::Proxy
+  def find_target; 17 end
+end
+
+class FakeProxy < MarkMapper::Plugins::Associations::Proxy
+  def find_target; [1, 2] end
+end
+
+describe "Proxy" do
+  before do
+    @owner = double('owner', :new? => false)
+    @association = double('association', :options => {:extend => []})
+
+    @proxy       = FakeProxy.new(@owner, @association)
+    @nil_proxy   = FakeNilProxy.new(@owner, @association)
+    @blank_proxy = FakeBlankProxy.new(@owner, @association)
+  end
+
+  it "should set target to nil when reset is called" do
+    @proxy.reset
+    @proxy.target.should be_nil
+  end
+
+  it "should be able to inspect the proxy" do
+    @proxy.inspect.should == '[1, 2]'
+  end
+
+  context "nil?" do
+    it "should be true if nil" do
+      @nil_proxy.nil?.should be_truthy
+    end
+
+    it "should be false if not nil" do
+      @proxy.nil?.should be_falsey
+    end
+  end
+
+  context "blank?" do
+    it "should be true if blank" do
+      @blank_proxy.blank?.should be_truthy
+      @nil_proxy.blank?.should be_truthy
+    end
+
+    it "should be false if not blank" do
+      @proxy.blank?.should be_falsey
+    end
+  end
+
+  context "present?" do
+    it "should be true if present" do
+      @proxy.present?.should be_truthy
+    end
+
+    it "should be false if not present" do
+      @blank_proxy.present?.should be_falsey
+      @nil_proxy.present?.should be_falsey
+    end
+  end
+
+  it "should delegate respond_to? to target" do
+    @proxy.respond_to?(:each).should be_truthy
+    @proxy.respond_to?(:size).should be_truthy
+    @proxy.respond_to?(:gsub).should be_falsey
+  end
+
+  it "should alias proxy owner to owner" do
+    @proxy.proxy_owner.should == @owner
+  end
+
+  it "should alias proxy target to target" do
+    @proxy.proxy_target.should == @target
+  end
+
+  context "send" do
+    it "should work if proxy responds to method" do
+      @proxy.send(:reset)
+      @proxy.target.should be_nil
+    end
+
+    it "should work if the target responds to the method" do
+      @proxy.send(:size).should == 2
+    end
+
+    it "should not work if neither the proxy or target respond to method" do
+      lambda { @proxy.send(:gsub) }.should raise_error
+    end
+
+    it "should work if a proc is passed" do
+      p = Proc.new {|x| x+1}
+      @proxy.send(:collect, &p).should == [2,3]
+    end
+  end
+end