mongo_mapper 0.12.0 → 0.13.0.beta1

data/spec/spec_helper.rb

@@ -0,0 +1,81 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'rubygems'
+require 'bundler/setup'
+require 'fileutils'
+require 'timecop'
+require "generator_spec/test_case"
+
+if RUBY_PLATFORM != "java"
+  if ENV['TRAVIS']
+    require 'coveralls'
+    Coveralls.wear!
+  elsif ENV['COVERAGE'] && RUBY_VERSION > "1.8"
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter 'spec'
+      add_group 'Core',         'lib/mongo_mapper'
+      add_group 'Rails',        'lib/rails'
+      add_group 'Extensions',   'lib/mongo_mapper/extensions'
+      add_group 'Plugins',      'lib/mongo_mapper/plugins'
+      add_group 'Associations', 'lib/mongo_mapper/plugins/associations'
+    end
+  end
+end
+
+require 'mongo_mapper'
+
+def Doc(name='Class', &block)
+  klass = Class.new
+  klass.class_eval do
+    include MongoMapper::Document
+
+    if name
+      class_eval "def self.name; '#{name}' end"
+      class_eval "def self.to_s; '#{name}' end"
+    else
+      set_collection_name :test
+    end
+  end
+
+  klass.class_eval(&block) if block_given?
+  klass.collection.remove
+  klass
+end
+
+def EDoc(name='Class', &block)
+  klass = Class.new do
+    include MongoMapper::EmbeddedDocument
+
+    if name
+      class_eval "def self.name; '#{name}' end"
+      class_eval "def self.to_s; '#{name}' end"
+    end
+  end
+
+  klass.class_eval(&block) if block_given?
+  klass
+end
+
+def drop_indexes(klass)
+  klass.collection.drop_indexes if klass.database.collection_names.include?(klass.collection.name)
+end
+
+log_dir = File.expand_path('../../log', __FILE__)
+FileUtils.mkdir_p(log_dir) unless File.exist?(log_dir)
+logger = Logger.new(log_dir + '/test.log')
+
+MongoMapper.connection = Mongo::MongoClient.new('127.0.0.1', 27017, :logger => logger)
+MongoMapper.database = "test"
+MongoMapper.database.collections.each { |c| c.drop_indexes }
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+  c.around(:each, :without_connection) do |example|
+    old, MongoMapper.connection = MongoMapper.connection, nil
+    example.run
+    MongoMapper.connection = old
+  end
+end
+

data/spec/support/matchers.rb

@@ -0,0 +1,24 @@
+RSpec::Matchers.define :have_error_on do |*args|
+  @message = nil
+  @attributes = [args]
+
+  chain :or do |*args|
+    @attributes << args
+  end
+
+  match do |model|
+    model.valid?
+    @has_errors = @attributes.detect {|attribute| model.errors[attribute[0]].present? }
+    if @message
+      !!@has_errors && model.errors[@has_errors[0]].include?(@has_errors[1])
+    else
+      !!@has_errors
+    end
+  end
+end
+
+RSpec::Matchers.define :have_index do |index_name|
+  match do |model|
+    model.collection.index_information.detect { |index| index[0] == index_name }.present?
+  end
+end

data/{test → spec/support}/models.rb

@@ -125,12 +125,7 @@ class Project
     end
   end
 
-  many :addresses do
-    def find_all_by_state(state)
-      # can't use select here for some reason
-      find_all { |a| a.state == state }
-    end
-  end
+  many :addresses
 end
 
 class Collaborator

data/spec/unit/associations/base_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+class FooMonster; end
+module AssociationSpec
+  include MongoMapper::Plugins::Associations
+
+  describe MongoMapper::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_true
+    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_true
+      end
+
+      it "should be false if not polymorphic" do
+        ManyAssociation.new(:bars).polymorphic?.should be_false
+      end
+    end
+
+    context "as?" do
+      it "should be true if one" do
+        OneAssociation.new(:foo, :as => :commentable).as?.should be_true
+      end
+
+      it "should be false if not one" do
+        ManyAssociation.new(:foo).as?.should be_false
+      end
+    end
+
+    context "in_array?" do
+      it "should be true if one" do
+        OneAssociation.new(:foo, :in => :list_ids).in_array?.should be_true
+      end
+
+      it "should be false if not one" do
+        ManyAssociation.new(:foo).in_array?.should be_false
+      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_true
+      end
+
+      it "should be false if class is not embeddable" do
+        base = ManyAssociation.new(:statuses)
+        base.embeddable?.should be_false
+
+        base = BelongsToAssociation.new(:project)
+        base.embeddable?.should be_false
+      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_true
+      end
+
+      it "should be false if not touch" do
+        BelongsToAssociation.new(:car).touch?.should be_false
+      end
+    end
+
+  end
+end

data/spec/unit/associations/belongs_to_association_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module BelongsToAssociation
+  include MongoMapper::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_false
+      end
+
+      it "should be false if class is not embeddable" do
+        base = BelongsToAssociation.new(:project)
+        base.embeddable?.should be_false
+      end
+    end
+  end
+end

data/spec/unit/associations/many_association_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+
+module ManyAssociationSpec
+  include MongoMapper::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_true
+      end
+
+      it "should be false if class is not embeddable" do
+        base = ManyAssociation.new(:statuses)
+        base.embeddable?.should be_false
+      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 MongoMapper::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_true
+      end
+
+      it "should be false if class is not embeddable" do
+        base = OneAssociation.new(:project)
+        base.embeddable?.should be_false
+      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/{test/unit/associations/test_proxy.rb → spec/unit/associations/proxy_spec.rb}

@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'spec_helper'
 
 class FakeNilProxy < MongoMapper::Plugins::Associations::Proxy
   def find_target; nil end
@@ -16,84 +16,84 @@ class FakeProxy < MongoMapper::Plugins::Associations::Proxy
   def find_target; [1, 2] end
 end
 
-class ProxyTest < Test::Unit::TestCase
-  def setup
-    @owner = mock('owner')
-    @owner.stubs(:new?).returns(false)
-    @association = mock('association')
-    @association.stubs(:options).returns({:extend => []})
+describe "Proxy" do
+  before do
+    @owner = double('owner')
+    @owner.stub(:new?).and_return(false)
+    @association = double('association')
+    @association.stub(:options).and_return({:extend => []})
 
     @proxy       = FakeProxy.new(@owner, @association)
     @nil_proxy   = FakeNilProxy.new(@owner, @association)
     @blank_proxy = FakeBlankProxy.new(@owner, @association)
   end
 
-  should "set target to nil when reset is called" do
+  it "should set target to nil when reset is called" do
     @proxy.reset
     @proxy.target.should be_nil
   end
 
-  should "be able to inspect the proxy" do
+  it "should be able to inspect the proxy" do
     @proxy.inspect.should == '[1, 2]'
   end
 
   context "nil?" do
-    should "be true if nil" do
+    it "should be true if nil" do
       @nil_proxy.nil?.should be_true
     end
 
-    should "be false if not nil" do
+    it "should be false if not nil" do
       @proxy.nil?.should be_false
     end
   end
 
   context "blank?" do
-    should "be true if blank" do
+    it "should be true if blank" do
       @blank_proxy.blank?.should be_true
       @nil_proxy.blank?.should be_true
     end
 
-    should "be false if not blank" do
+    it "should be false if not blank" do
       @proxy.blank?.should be_false
     end
   end
 
   context "present?" do
-    should "be true if present" do
+    it "should be true if present" do
       @proxy.present?.should be_true
     end
 
-    should "be false if not present" do
+    it "should be false if not present" do
       @blank_proxy.present?.should be_false
       @nil_proxy.present?.should be_false
     end
   end
 
-  should "delegate respond_to? to target" do
+  it "should delegate respond_to? to target" do
     @proxy.respond_to?(:each).should be_true
     @proxy.respond_to?(:size).should be_true
     @proxy.respond_to?(:gsub).should be_false
   end
 
-  should "alias proxy owner to owner" do
+  it "should alias proxy owner to owner" do
     @proxy.proxy_owner.should == @owner
   end
 
-  should "alias proxy target to target" do
+  it "should alias proxy target to target" do
     @proxy.proxy_target.should == @target
   end
 
   context "send" do
-    should "work if proxy responds to method" do
+    it "should work if proxy responds to method" do
       @proxy.send(:reset)
       @proxy.target.should be_nil
     end
 
-    should "work if the target responds to the method" do
+    it "should work if the target responds to the method" do
       @proxy.send(:size).should == 2
     end
 
-    should "not work if neither the proxy or target respond to method" do
+    it "should not work if neither the proxy or target respond to method" do
       lambda { @proxy.send(:gsub) }.should raise_error
     end
   end