mongo_mapper-rails3 0.7.0.1 → 0.7.2

data/test/support/custom_matchers.rb

@@ -1,55 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,207 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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