mongo_mapper-rails3 0.7.0.1

data/test/support/custom_matchers.rb

@@ -0,0 +1,55 @@
+module CustomMatchers
+  custom_matcher :be_nil do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be nil but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be nil but it was"
+    receiver.nil?
+  end
+  
+  custom_matcher :be_blank do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be blank but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be blank but it was"
+    receiver.blank?
+  end
+  
+  custom_matcher :be_true do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be true but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be true but it was"
+    receiver.eql?(true)
+  end
+  
+  custom_matcher :be_false do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be false but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be false but it was"
+    receiver.eql?(false)
+  end
+
+  custom_matcher :be_valid do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected to be valid but it was invalid #{receiver.errors.inspect}"
+    matcher.negative_failure_message = "Expected to be invalid but it was valid #{receiver.errors.inspect}"
+    receiver.valid?
+  end
+
+  custom_matcher :have_error_on do |receiver, matcher, args|
+    receiver.valid?
+    attribute = args[0]
+    expected_message = args[1]
+    
+    if expected_message.nil?
+      matcher.positive_failure_message = "#{receiver} had no errors on #{attribute}"
+      matcher.negative_failure_message = "#{receiver} had errors on #{attribute} #{receiver.errors.inspect}"
+      receiver.errors[attribute].size > 0
+    else
+      actual = receiver.errors[attribute].first
+      matcher.positive_failure_message = %Q(Expected error on #{attribute} to be "#{expected_message}" but was "#{actual}")
+      matcher.negative_failure_message = %Q(Expected error on #{attribute} not to be "#{expected_message}" but was "#{actual}")
+      actual == expected_message
+    end
+  end
+  
+  custom_matcher :have_index do |receiver, matcher, args|
+    index_name = args[0]
+    matcher.positive_failure_message = "#{receiver} does not have index named #{index_name}, but should"
+    matcher.negative_failure_message = "#{receiver} does have index named #{index_name}, but should not"
+    !receiver.collection.index_information.detect { |index| index[0] == index_name }.nil?
+  end
+end

data/test/support/timing.rb

@@ -0,0 +1,16 @@
+class Test::Unit::TestCase
+  def run_with_test_timing(*args, &block)    
+    begin_time = Time.now
+    run_without_test_timing(*args, &block)
+    end_time = Time.now
+ 
+    duration = end_time - begin_time
+    threshold = 1.0
+    
+    if duration > threshold
+      puts "\nSLOW TEST: #{duration} - #{self.name}"
+    end
+  end
+  
+  alias_method_chain :run, :test_timing unless method_defined?(:run_without_test_timing)
+end

data/test/test_helper.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/mongo_mapper')
+
+require 'active_support/core_ext/logger'
+require 'active_support/core_ext/module/aliasing'
+
+require 'matchy'
+require 'shoulda'
+require 'timecop'
+require 'mocha'
+require 'pp'
+
+require 'support/custom_matchers'
+require 'support/timing'
+
+class Test::Unit::TestCase
+  include CustomMatchers
+
+  def Doc(name='Unnamed', &block)
+    klass = Class.new do
+      include MongoMapper::Document
+      set_collection_name "test#{rand(20)}"
+
+      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.collection.remove
+    klass
+  end
+
+  def EDoc(name='Unnamed', &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)
+    if klass.database.collection_names.include?(klass.collection.name)
+      klass.collection.drop_indexes
+    end
+  end
+end
+
+test_dir = File.expand_path(File.dirname(__FILE__) + '/../tmp')
+FileUtils.mkdir_p(test_dir) unless File.exist?(test_dir)
+
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017, {:logger => Logger.new(test_dir + '/test.log')})
+MongoMapper.database = 'test'

data/test/unit/associations/test_base.rb

@@ -0,0 +1,207 @@
+require 'test_helper'
+require 'models'
+
+class FooMonster; end
+
+class AssociationBaseTest < Test::Unit::TestCase
+  include MongoMapper::Plugins::Associations
+  
+  should "initialize with type and name" do
+    base = Base.new(:many, :foos)
+    base.type.should == :many
+    base.name.should == :foos
+  end
+  
+  should "also allow options when initializing" do
+    base = Base.new(:many, :foos, :polymorphic => true)
+    base.options[:polymorphic].should be_true
+  end
+  
+  context "class_name" do
+    should "work for belongs_to" do
+      Base.new(:belongs_to, :user).class_name.should == 'User'
+    end
+    
+    should "work for many" do
+      Base.new(:many, :smart_people).class_name.should == 'SmartPerson'
+    end
+    
+    should "be changeable using class_name option" do
+      base = Base.new(:many, :smart_people, :class_name => 'IntelligentPerson')
+      base.class_name.should == 'IntelligentPerson'
+    end
+  end
+  
+  context "klass" do
+    should "default to class_name constantized" do
+      Base.new(:belongs_to, :foo_monster).klass.should == FooMonster
+    end
+    
+    should "be the specified class" do
+      anonnymous_class = Class.new
+      Base.new(:belongs_to, :foo_monster, :class => anonnymous_class).klass.should == anonnymous_class
+    end
+  end
+  
+  context "many?" do
+    should "be true if many" do
+      Base.new(:many, :foos).many?.should be_true
+    end
+    
+    should "be false if not many" do
+      Base.new(:belongs_to, :foo).many?.should be_false
+      Base.new(:one, :foo).many?.should be_false
+    end
+  end
+  
+  context "one?" do
+    should "be true if one" do
+      Base.new(:one, :foo).one?.should be_true
+    end
+    
+    should "be false if not one" do
+      Base.new(:many, :foo).one?.should be_false
+    end
+  end
+  
+  context "belongs_to?" do
+    should "be true if belongs_to" do
+      Base.new(:belongs_to, :foo).belongs_to?.should be_true
+    end
+    
+    should "be false if not belongs_to" do
+      Base.new(:many, :foos).belongs_to?.should be_false
+    end
+  end
+  
+  context "polymorphic?" do
+    should "be true if polymorphic" do
+      Base.new(:many, :foos, :polymorphic => true).polymorphic?.should be_true
+    end
+    
+    should "be false if not polymorphic" do
+      Base.new(:many, :bars).polymorphic?.should be_false
+    end
+  end
+  
+  context "as?" do
+    should "be true if one" do
+      Base.new(:one, :foo, :as => :commentable).as?.should be_true
+    end
+    
+    should "be false if not one" do
+      Base.new(:many, :foo).as?.should be_false
+    end
+  end
+  
+  context "in_array?" do
+    should "be true if one" do
+      Base.new(:one, :foo, :in => :list_ids).in_array?.should be_true
+    end
+    
+    should "be false if not one" do
+      Base.new(:many, :foo).in_array?.should be_false
+    end
+  end
+  
+  context "query_options" do
+    should "default to empty hash" do
+      base = Base.new(:many, :foos)
+      base.query_options.should == {}
+    end
+    
+    should "work with order" do
+      base = Base.new(:many, :foos, :order => 'position')
+      base.query_options.should == {:order => 'position'}
+    end
+    
+    should "correctly parse from options" do
+      base = Base.new(:many, :foos, :order => 'position', :somekey => 'somevalue')
+      base.query_options.should == {:order => 'position', :somekey => 'somevalue'}
+    end
+  end
+  
+  context "type_key_name" do
+    should "be _type for many" do
+      Base.new(:many, :foos).type_key_name.should == '_type'
+    end
+    
+    should "be association name _ type for belongs_to" do
+      Base.new(:belongs_to, :foo).type_key_name.should == 'foo_type'
+    end
+  end
+  
+  context "foreign_key" do
+    should "default to assocation name _id for belongs to" do
+      base = Base.new(:belongs_to, :foo)
+      base.foreign_key.should == 'foo_id'
+    end
+    
+    should "be overridable with :foreign_key option" do
+      base = Base.new(:belongs_to, :foo, :foreign_key => 'foobar_id')
+      base.foreign_key.should == 'foobar_id'
+    end
+  end
+  
+  should "have ivar that is association name" do
+    Base.new(:belongs_to, :foo).ivar.should == '@_foo'
+  end
+  
+  context "embeddable?" do
+    should "be true if class is embeddable" do
+      base = Base.new(:many, :medias)
+      base.embeddable?.should be_true
+    end
+    
+    should "be false if class is not embeddable" do
+      base = Base.new(:many, :statuses)
+      base.embeddable?.should be_false
+      
+      base = Base.new(:belongs_to, :project)
+      base.embeddable?.should be_false
+    end
+  end
+  
+  context "proxy_class" do
+    should "be ManyDocumentsProxy for many" do      
+      base = Base.new(:many, :statuses)
+      base.proxy_class.should == ManyDocumentsProxy
+    end
+    
+    should "be ManyPolymorphicProxy for polymorphic many" do
+      base = Base.new(:many, :messages, :polymorphic => true)
+      base.proxy_class.should == ManyPolymorphicProxy
+    end
+    
+    should "be ManyEmbeddedProxy for many embedded" do
+      base = Base.new(:many, :medias)
+      base.proxy_class.should == ManyEmbeddedProxy
+    end
+    
+    should "be ManyEmbeddedPolymorphicProxy for polymorphic many embedded" do
+      base = Base.new(:many, :medias, :polymorphic => true)
+      base.proxy_class.should == ManyEmbeddedPolymorphicProxy
+    end
+    
+    should "be BelongsToProxy for belongs_to" do
+      base = Base.new(:belongs_to, :project)
+      base.proxy_class.should == BelongsToProxy
+    end
+    
+    should "be BelongsToPolymorphicProxy for polymorphic belongs_to" do
+      base = Base.new(:belongs_to, :target, :polymorphic => true)
+      base.proxy_class.should == BelongsToPolymorphicProxy
+    end
+    
+    should "be OneProxy for one" do
+      base = Base.new(:one, :target, :polymorphic => true)
+      base.proxy_class.should == OneProxy
+    end
+    
+    should "be InArrayProxy for many with :in option" do
+      base = Base.new(:many, :messages, :in => :message_ids)
+      base.proxy_class.should == InArrayProxy
+    end
+  end
+  
+end

data/test/unit/associations/test_proxy.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class FakeNilProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; nil end
+end
+
+class FakeBlankProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; '' end
+end
+
+class FakeNumberProxy < MongoMapper::Plugins::Associations::Proxy
+  def find_target; 17 end
+end
+
+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 => []})
+
+    @proxy       = FakeProxy.new(@owner, @association)
+    @nil_proxy   = FakeNilProxy.new(@owner, @association)
+    @blank_proxy = FakeBlankProxy.new(@owner, @association)
+  end
+  
+  should 'return true for === target' do
+    @proxy = FakeProxy.new(@owner, @association)
+    @proxy.should === Array
+  end
+  
+  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
+    @proxy.inspect.should == '[1, 2]'
+  end
+  
+  context "nil?" do
+    should "be true if nil" do
+      @nil_proxy.nil?.should be_true
+    end
+    
+    should "be false if not nil" do
+      @proxy.nil?.should be_false
+    end
+  end
+  
+  context "blank?" do
+    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
+      @proxy.blank?.should be_false
+    end
+  end
+  
+  context "present?" do
+    should "be true if present" do
+      @proxy.present?.should be_true
+    end
+    
+    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
+    @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
+    @proxy.proxy_owner.should == @owner
+  end
+  
+  should "alias proxy target to target" do
+    @proxy.proxy_target.should == @target
+  end
+  
+  context "send" do
+    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
+      @proxy.send(:size).should == 2
+    end
+    
+    should "not work if neither the proxy or target respond to method" do
+      lambda { @proxy.send(:gsub) }.should raise_error
+    end
+  end
+end

data/test/unit/serializers/test_json_serializer.rb

@@ -0,0 +1,189 @@
+require 'test_helper'
+
+class JsonSerializationTest < Test::Unit::TestCase
+  class Tag
+    include MongoMapper::EmbeddedDocument
+    key :name, String
+  end
+  
+  class Contact
+    include MongoMapper::Document
+    key :name, String
+    key :age, Integer
+    key :created_at, Time
+    key :awesome, Boolean
+    key :preferences, Hash
+    
+    many :tags, :class_name => 'JsonSerializationTest::Tag'
+  end
+  
+  def setup
+    Contact.include_root_in_json = false
+    @contact = Contact.new(
+      :name        => 'Konata Izumi',
+      :age         => 16,
+      :created_at  => Time.utc(2006, 8, 1),
+      :awesome     => true,
+      :preferences => { :shows => 'anime' }
+    )
+  end
+  
+  should "include demodulized root" do
+    Contact.include_root_in_json = true
+    assert_match %r{^\{"contact":[ ]?\{}, ActiveSupport::JSON.encode(@contact)
+  end
+  
+  should "encode all encodable attributes" do
+    json = ActiveSupport::JSON.encode(@contact)
+
+    assert_no_match %r{"_id"}, json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
+    assert_match %r{"awesome":true}, json
+    assert_match %r{"preferences":\{"shows":"anime"\}}, json
+  end
+  
+  should "allow attribute filtering with only" do
+    json = ActiveSupport::JSON.encode(@contact, :only => [:name, :age])
+
+    assert_no_match %r{"_id"}, json
+    assert_match %r{"name":"Konata Izumi"}, json
+    assert_match %r{"age":16}, json
+    assert_no_match %r{"awesome"}, json
+    assert_no_match %r{"created_at"}, json
+    assert_no_match %r{"preferences"}, json
+  end
+  
+  should "allow attribute filtering with except" do
+    json = ActiveSupport::JSON.encode(@contact, :except => [:name, :age])
+
+    assert_no_match %r{"_id"}, json
+    assert_no_match %r{"name"}, json
+    assert_no_match %r{"age"}, json
+    assert_match %r{"awesome"}, json
+    assert_match %r{"created_at"}, json
+    assert_match %r{"preferences"}, json
+  end
+  
+  context "_id key" do
+    should "not be included by default" do
+      json = ActiveSupport::JSON.encode(@contact)
+      assert_no_match %r{"_id":}, json
+    end
+    
+    should "not be included even if :except is used" do
+      json = ActiveSupport::JSON.encode(@contact, :except => :name)
+      assert_no_match %r{"_id":}, json
+    end
+  end
+  
+  context "id method" do
+    setup do
+      def @contact.label; "Has cheezburger"; end
+      def @contact.favorite_quote; "Constraints are liberating"; end
+    end
+    
+    should "be included by default" do
+      json = ActiveSupport::JSON.encode(@contact)
+      assert_match %r{"id"}, json
+    end
+    
+    should "be included when single method included" do
+      json = ActiveSupport::JSON.encode(@contact, :methods => :label)
+      assert_match %r{"id"}, json
+      assert_match %r{"label":"Has cheezburger"}, json
+      assert_match %r{"name":"Konata Izumi"}, json
+      assert_no_match %r{"favorite_quote":"Constraints are liberating"}, json
+    end
+    
+    should "be included when multiple methods included" do
+      json = ActiveSupport::JSON.encode(@contact, :methods => [:label, :favorite_quote])
+      assert_match %r{"id"}, json
+      assert_match %r{"label":"Has cheezburger"}, json
+      assert_match %r{"favorite_quote":"Constraints are liberating"}, json
+      assert_match %r{"name":"Konata Izumi"}, json
+    end
+    
+    should "not be included if :only is present" do
+      json = ActiveSupport::JSON.encode(@contact, :only => :name)
+      assert_no_match %r{"id":}, json
+    end
+  end  
+  
+  context "including methods" do
+    setup do
+      def @contact.label; "Has cheezburger"; end
+      def @contact.favorite_quote; "Constraints are liberating"; end
+    end
+    
+    should "include single method" do
+      json = ActiveSupport::JSON.encode(@contact, :methods => :label)
+      assert_match %r{"label":"Has cheezburger"}, json
+    end
+    
+    should "include multiple methods" do
+      json = ActiveSupport::JSON.encode(@contact, :only => :name, :methods => [:label, :favorite_quote])
+      assert_match %r{"label":"Has cheezburger"}, json
+      assert_match %r{"favorite_quote":"Constraints are liberating"}, json
+      assert_match %r{"name":"Konata Izumi"}, json
+      assert_no_match %r{"age":16}, json
+      assert_no_match %r{"awesome"}, json
+      assert_no_match %r{"created_at"}, json
+      assert_no_match %r{"preferences"}, json
+    end
+  end
+  
+  context "array of records" do
+    setup do
+      @contacts = [
+        Contact.new(:name => 'David', :age => 39),
+        Contact.new(:name => 'Mary', :age => 14)
+      ]
+    end
+
+    should "allow attribute filtering with only" do
+      json = ActiveSupport::JSON.encode(@contacts, :only => :name)
+      assert_match %r{\{"name":"David"\}}, json
+      assert_match %r{\{"name":"Mary"\}}, json
+    end
+    
+    should "allow attribute filtering with except" do
+      json = ActiveSupport::JSON.encode(@contacts, :except => [:name, :preferences, :awesome, :created_at, :updated_at])
+      assert_match %r{"age":39},          json
+      assert_match %r{"age":14},          json
+      assert_no_match %r{"name":},        json
+      assert_no_match %r{"preferences":}, json
+      assert_no_match %r{"awesome":},     json
+      assert_no_match %r{"created_at":},  json
+      assert_no_match %r{"updated_at":},  json
+    end
+  end
+  
+  should "allow options for hash of records" do
+    contacts = {
+      1 => Contact.new(:name => 'David', :age => 39),
+      2 => Contact.new(:name => 'Mary', :age => 14)
+    }
+    json = ActiveSupport::JSON.encode(contacts, :only => [1, :name])
+    assert_match %r{"1":},               json
+    assert_match %r{\{"name":"David"\}}, json
+    assert_no_match %r{"2":},            json
+  end
+  
+  should "include embedded attributes" do
+    contact = Contact.new(:name => 'John', :age => 27)
+    contact.tags = [Tag.new(:name => 'awesome'), Tag.new(:name => 'ruby')]
+    json = ActiveSupport::JSON.encode(contact)
+    assert_match %r{"tags":}, json
+    assert_match %r{"name":"awesome"}, json
+    assert_match %r{"name":"ruby"}, json
+  end
+  
+  should "include dynamic attributes" do
+    contact = Contact.new(:name => 'John', :age => 27, :foo => 'bar')
+    contact['smell'] = 'stinky'
+    json = ActiveSupport::JSON.encode(contact)
+    assert_match %r{"smell":"stinky"}, json
+  end
+end