jmonteiro-mongo_mapper 0.1.0

data/test/unit/associations/test_proxy.rb

@@ -0,0 +1,103 @@
+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 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": \{}, @contact.to_json
+  end
+  
+  should "encode all encodable attributes" do
+    json = @contact.to_json
+
+    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 = @contact.to_json(: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 = @contact.to_json(: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 = @contact.to_json
+      assert_no_match %r{"_id":}, json
+    end
+    
+    should "not be included even if :except is used" do
+      json = @contact.to_json(: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 = @contact.to_json
+      assert_match %r{"id"}, json
+    end
+    
+    should "be included when single method included" do
+      json = @contact.to_json(: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 = @contact.to_json(: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 = @contact.to_json(: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 = @contact.to_json(:methods => :label)
+      assert_match %r{"label":"Has cheezburger"}, json
+    end
+    
+    should "include multiple methods" do
+      json = @contact.to_json(: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 = @contacts.to_json(:only => :name)
+      assert_match %r{\{"name":"David"\}}, json
+      assert_match %r{\{"name":"Mary"\}}, json
+    end
+    
+    should "allow attribute filtering with except" do
+      json = @contacts.to_json(: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 = contacts.to_json(: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 = contact.to_json
+    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 = contact.to_json
+    assert_match %r{"smell":"stinky"}, json
+  end
+end

data/test/unit/test_descendant_appends.rb

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

@@ -0,0 +1,203 @@
+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 nil" do
+      Enter.descendants.should be_nil
+    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(Mongo::ObjectID)
+    end
+    
+    should "have to_param that is string representation of id" do
+      doc = @document.new(:id => Mongo::ObjectID.new)
+      doc.to_param.should == doc.id.to_s
+      doc.to_param.should be_instance_of(String)
+    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 = Mongo::ObjectID.new
+      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' => Mongo::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