mongo_mapper_ign 0.7.4 → 0.7.6

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,202 +0,0 @@
-require 'test_helper'
-require 'active_support/version'
-
-class JsonSerializationTest < Test::Unit::TestCase
-  
-  # Helper function in case things change in the future 
-  # - replacing all those to_json calls was a nightmare
-  def convert_to_json object, options = {}
-    ActiveSupport::JSON.encode(object, options)
-  end
-  
-  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":\s?\{}, convert_to_json(@contact)
-  end
-  
-  should "encode all encodable attributes" do
-    json = convert_to_json(@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 = convert_to_json(@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 = convert_to_json(@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 = convert_to_json(@contact)
-      assert_no_match %r{"_id":}, json
-    end
-    
-    should "not be included even if :except is used" do
-      json = convert_to_json(@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 = convert_to_json(@contact)
-      assert_match %r{"id"}, json
-    end
-    
-    should "be included when single method included" do
-      json = convert_to_json(@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 = convert_to_json(@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 = convert_to_json(@contact, :only => :name)
-      assert_no_match %r{"id":}, json
-    end
-    
-    should "be represented by a string" do
-      json = convert_to_json(@contact)
-      assert_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 = convert_to_json(@contact, :methods => :label)
-      assert_match %r{"label":"Has cheezburger"}, json
-    end
-    
-    should "include multiple methods" do
-      json = convert_to_json(@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 =convert_to_json(@contacts, :only => :name)
-      assert_match %r{\{"name":"David"\}}, json
-      assert_match %r{\{"name":"Mary"\}}, json
-    end
-    
-    should "allow attribute filtering with except" do
-      json = convert_to_json(@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 = convert_to_json(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 = convert_to_json(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 = convert_to_json(contact)
-    assert_match %r{"smell":"stinky"}, json
-  end
-end

data/test/unit/test_descendant_appends.rb

@@ -1,71 +0,0 @@
-require 'test_helper'
-
-class DescendantAppendsTest < Test::Unit::TestCase
-  context "Document" do
-    should "default descendants to a new set" do
-      MongoMapper::Document.descendants.should be_instance_of(Set)
-    end
-    
-    should 'allow extensions to Document to be appended' do
-      module Extension; def test_this_extension; end end
-      MongoMapper::Document.append_extensions(Extension)
-      article = Doc()
-      article.should respond_to(:test_this_extension)
-    end
-
-    should 'add appended extensions to classes that include Document before they are added' do
-      module Extension; def test_this_extension; end end
-      article = Doc()
-      MongoMapper::Document.append_extensions(Extension)
-      article.should respond_to(:test_this_extension)
-    end
-
-    should 'allow inclusions to Document to be appended' do
-      module Inclusion; def test_this_inclusion; end end
-      MongoMapper::Document.append_inclusions(Inclusion)
-      article = Doc()
-      article.new.should respond_to(:test_this_inclusion)
-    end
-
-    should 'add appended inclusions to classes that include Document before they are added' do
-      module Inclusion; def test_this_inclusion; end end
-      article = Doc()
-      MongoMapper::Document.append_inclusions(Inclusion)
-      article.new.should respond_to(:test_this_inclusion)
-    end
-  end
-  
-  context "EmbeddedDocument" do
-    should "default descendants to a new set" do
-      MongoMapper::EmbeddedDocument.descendants.should be_instance_of(Set)
-    end
-    
-    should 'allow extensions to Document to be appended' do
-      module Extension; def test_this_extension; end end
-      MongoMapper::EmbeddedDocument.append_extensions(Extension)
-      article = EDoc()
-      article.should respond_to(:test_this_extension)
-    end
-
-    should 'add appended extensions to classes that include Document before they are added' do
-      module Extension; def test_this_extension; end end
-      article = EDoc()
-      MongoMapper::EmbeddedDocument.append_extensions(Extension)
-      article.should respond_to(:test_this_extension)
-    end
-
-    should 'allow inclusions to Document to be appended' do
-      module Inclusion; def test_this_inclusion; end end
-      MongoMapper::EmbeddedDocument.append_inclusions(Inclusion)
-      article = EDoc()
-      article.new.should respond_to(:test_this_inclusion)
-    end
-
-    should 'add appended inclusions to classes that include Document before they are added' do
-      module Inclusion; def test_this_inclusion; end end
-      article = EDoc()
-      MongoMapper::EmbeddedDocument.append_inclusions(Inclusion)
-      article.new.should respond_to(:test_this_inclusion)
-    end
-  end
-end

data/test/unit/test_document.rb

@@ -1,225 +0,0 @@
-require 'test_helper'
-require 'models'
-
-class DocumentTest < Test::Unit::TestCase
-  context "The Document Class" do
-    setup do
-      @document = Doc()
-    end
-    
-    should "return false for embeddable" do
-      Doc().embeddable?.should be_false
-    end
-    
-    should "have logger method" do
-      @document.logger.should == MongoMapper.logger
-      @document.logger.should be_instance_of(Logger)
-    end
-
-    should "use default database by default" do
-      @document.database.should == MongoMapper.database
-    end
-
-    should "have a connection" do
-      @document.connection.should be_instance_of(Mongo::Connection)
-    end
-
-    should "allow setting different connection without affecting the default" do
-      conn = Mongo::Connection.new
-      @document.connection conn
-      @document.connection.should == conn
-      @document.connection.should_not == MongoMapper.connection
-    end
-
-    should "allow setting a different database without affecting the default" do
-      @document.set_database_name 'test2'
-      @document.database_name.should == 'test2'
-      @document.database.name.should == 'test2'
-
-      another_document = Doc()
-      another_document.database.should == MongoMapper.database
-    end
-    
-    should "default collection name to class name tableized" do
-      class ::Item
-        include MongoMapper::Document
-      end
-      
-      Item.collection.should be_instance_of(Mongo::Collection)
-      Item.collection.name.should == 'items'
-    end
-    
-    should "default collection name of namespaced class to tableized with dot separation" do
-      module ::BloggyPoo
-        class Post
-          include MongoMapper::Document
-        end
-      end
-
-      BloggyPoo::Post.collection.should be_instance_of(Mongo::Collection)
-      BloggyPoo::Post.collection.name.should == 'bloggy_poo.posts'
-    end
-
-    should "allow setting the collection name" do
-      @document.set_collection_name('foobar')
-      @document.collection.should be_instance_of(Mongo::Collection)
-      @document.collection.name.should == 'foobar'
-    end
-  end # Document class
-  
-  context "Documents that inherit from other documents" do
-    should "default collection name to inherited class" do
-      Message.collection_name.should == 'messages'
-      Enter.collection_name.should   == 'messages'
-      Exit.collection_name.should    == 'messages'
-      Chat.collection_name.should    == 'messages'
-    end
-
-    should "default associations to inherited class" do
-      Message.associations.keys.should include("room")
-      Enter.associations.keys.should   include("room")
-      Exit.associations.keys.should    include("room")
-      Chat.associations.keys.should    include("room")
-    end
-  end
-  
-  context "descendants" do
-    should "default to an empty array" do
-      Enter.descendants.should == []
-    end
-
-    should "be recorded" do
-      Message.descendants.should == [Enter, Exit, Chat]
-    end
-  end
-
-  context "An instance of a document" do
-    setup do
-      @document = Doc do
-        key :name, String
-        key :age, Integer
-      end
-    end
-    
-    should "create id during initialization" do
-      @document.new._id.should be_instance_of(BSON::ObjectID)
-    end
-    
-    should "have access to logger" do
-      doc = @document.new
-      doc.logger.should == @document.logger
-      doc.logger.should be_instance_of(Logger)
-    end
-
-    should "have access to the class's collection" do
-      doc = @document.new
-      doc.collection.name.should == @document.collection.name
-    end
-
-    should "use default values if defined for keys" do
-      @document.key :active, Boolean, :default => true
-
-      @document.new.active.should be_true
-      @document.new(:active => false).active.should be_false
-    end
-    
-    should "use default values if defined even when custom data type" do
-      @document.key :window, WindowSize, :default => WindowSize.new(600, 480)
-      
-      doc = @document.new
-      doc.window.should == WindowSize.new(600, 480)
-    end
-
-    context "root document" do
-      should "set self to the root document on embedded documents" do        
-        klass = Doc()
-        pets = EDoc()
-        
-        klass.many :pets, :class => pets
-        
-        doc = klass.new(:pets => [{}])
-        doc.pets.first._root_document.should == doc        
-      end
-    end
-
-    context "new?" do
-      should "be true if no id" do
-        @document.new.new?.should be_true
-      end
-      
-      should "be true if id but using custom id and not saved yet" do
-        @document.key :_id, String
-        doc = @document.new
-        doc.id = '1234'
-        doc.new?.should be_true
-      end
-    end
-
-    context "clone" do
-      should "be new" do
-        doc = @document.create(:name => "foo", :age => 27)
-        clone = doc.clone
-        clone.should be_new
-      end
-
-      should "copy the attributes" do
-        doc = @document.create(:name => "foo", :age => 27)
-        clone = doc.clone
-        clone.name.should == "foo"
-        clone.age.should == 27
-      end
-    end
-
-    should "call inspect on the document's attributes instead of to_s when inspecting the document" do
-      doc = @document.new(:animals => %w(dog cat))
-      doc.inspect.should include(%(animals: ["dog", "cat"]))
-    end
-
-    context "equality" do
-      setup do
-        @oid = BSON::ObjectID.new
-      end
-      
-      should "delegate hash to _id" do
-        doc = @document.new
-        doc.hash.should == doc._id.hash
-      end
-      
-      should "delegate eql to ==" do
-        doc = @document.new
-        other = @document.new
-        doc.eql?(other).should == (doc == other)
-        doc.eql?(doc).should == (doc == doc)
-      end
-      
-      should "know if same object as another" do
-        doc = @document.new
-        doc.should equal(doc)
-        doc.should_not equal(@document.new)
-      end
-      
-      should "allow set operations on array of documents" do
-        @document.key :parent_id, ObjectId
-        @document.belongs_to :parent, :class => @document
-        
-        parent = @document.create
-        child = @document.create(:parent => parent)
-        
-        ([child.parent] & [parent]).should == [parent]
-      end
-      
-      should "be equal if id and class are the same" do
-        (@document.new('_id' => @oid) == @document.new('_id' => @oid)).should be(true)
-      end
-
-      should "not be equal if class same but id different" do
-        (@document.new('_id' => @oid) == @document.new('_id' => BSON::ObjectID.new)).should be(false)
-      end
-
-      should "not be equal if id same but class different" do
-        another_document = Doc()
-        (@document.new('_id' => @oid) == another_document.new('_id' => @oid)).should be(false)
-      end
-    end
-  end # instance of a document
-end # DocumentTest