jamieorc-mongo_mapper 0.11.1.1

data/test/unit/serializers/test_xml_serializer.rb

@@ -0,0 +1,196 @@
+require 'test_helper'
+
+class XmlSerializationTest < 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 => 'XmlSerializationTest::Tag'
+  end
+
+  def setup
+    Kernel.const_set('TopLevelContact', Doc('TopLevelContact'))
+    TopLevelContact.key :name, String
+
+    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' }
+    )
+    @top_level_contact = TopLevelContact.new(
+      :name        => 'Konata Izumi'
+    )
+  end
+
+  def teardown
+    Kernel.send(:remove_const, 'TopLevelContact') if Object.const_defined?('TopLevelContact')
+  end
+
+  should "include root for class with no module" do
+    assert_match %r{<top-level-contact>}, @top_level_contact.to_xml
+  end
+
+  should "include demodulized root" do
+    assert_match %r{<contact>}, @contact.to_xml
+  end
+
+  should "encode all encodable attributes" do
+    xml = @contact.to_xml
+
+    assert_no_match %r{_id}, xml
+    assert_match %r{<id>#{@contact.id}</id>}, xml
+    assert_match %r{<name>Konata Izumi</name>}, xml
+    assert_match %r{<age.*>16</age>}, xml
+    assert_match %r(<created-at type="datetime">), xml
+    assert_match %r{<awesome type="boolean">true</awesome>}, xml
+    assert_match %r{<preferences>}, xml
+    assert_match %r{<shows>anime</shows>}, xml
+  end
+
+  should "allow attribute filtering with only" do
+    xml = @contact.to_xml(:only => [:name, :age])
+
+    assert_no_match %r{<id>}, xml
+    assert_match %r{<name>Konata Izumi</name>}, xml
+    assert_match %r{<age type="integer">16</age>}, xml
+    assert_no_match %r{awesome}, xml
+    assert_no_match %r{created-at}, xml
+    assert_no_match %r{preferences}, xml
+  end
+
+  should "allow attribute filtering with except" do
+    xml = @contact.to_xml(:except => [:name, :age])
+
+    assert_no_match %r{<name>Konata Izumi</name>}, xml
+    assert_no_match %r{<age type="integer">16</age>}, xml
+    assert_match %r{<id>}, xml
+    assert_match %r{awesome}, xml
+    assert_match %r{created-at}, xml
+    assert_match %r{preferences}, xml
+  end
+
+  context "_id key" do
+    should "not be included by default" do
+      assert_no_match %r{_id}, @contact.to_xml
+    end
+
+    should "not be included even if :except is used" do
+      assert_no_match %r{_id}, @contact.to_xml(:except => :name)
+    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
+      assert_match %r{<id>#{@contact.id}</id>}, @contact.to_xml
+    end
+
+    should "be included when single method included" do
+      xml = @contact.to_xml(:methods => :label)
+      assert_match %r{<id>}, xml
+      assert_match %r{<label>Has cheezburger</label>}, xml
+      assert_match %r{<name>Konata Izumi</name>}, xml
+      assert_no_match %r{favorite_quote}, xml
+    end
+
+    should "be included when multiple methods included" do
+      xml = @contact.to_xml(:methods => [:label, :favorite_quote])
+      assert_match %r{<id>}, xml
+      assert_match %r{<label>Has cheezburger</label>}, xml
+      assert_match %r{<name>Konata Izumi</name>}, xml
+      assert_match %r{<favorite-quote>Constraints are liberating</favorite-quote>}, xml
+    end
+
+    should "not be included if :only is present" do
+      assert_no_match %r{<id}, @contact.to_xml(:only => :name)
+    end
+
+    should "be represented by a string" do
+      assert_match %r{<id>}, @contact.to_xml
+    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
+      assert_match %r{<label>Has cheezburger</label>}, @contact.to_xml(:methods => :label)
+    end
+
+    should "include multiple methods" do
+      xml = @contact.to_xml(:only => :name, :methods => [:label, :favorite_quote])
+      assert_match %r{<label>Has cheezburger</label>}, xml
+      assert_match %r{<favorite-quote>Constraints are liberating</favorite-quote>}, xml
+      assert_match %r{<name>Konata Izumi</name>}, xml
+      assert_no_match %r{age}, xml
+      assert_no_match %r{awesome}, xml
+      assert_no_match %r{created-at}, xml
+      assert_no_match %r{preferences}, xml
+
+      # Assert only one tag is created
+      xml.scan(/favorite-quote/).size.should == 2
+    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
+      xml = @contacts.to_xml(:only => :name)
+      assert_match %r{<name>David</name>}, xml
+      assert_match %r{<name>Mary</name>},  xml
+    end
+
+    should "allow attribute filtering with except" do
+      xml = @contacts.to_xml(:except => [:name, :preferences, :awesome, :created_at, :updated_at])
+      assert_match %r{<age type="integer">39</age>}, xml
+      assert_match %r{<age type="integer">14</age>}, xml
+      assert_no_match %r{name},        xml
+      assert_no_match %r{preferences}, xml
+      assert_no_match %r{awesome},     xml
+      assert_no_match %r{created-at},  xml
+      assert_no_match %r{updated-at},  xml
+    end
+  end
+
+  should "include embedded attributes" do
+    contact = Contact.new(:name => 'John', :age => 27)
+    contact.tags = [Tag.new(:name => 'awesome'), Tag.new(:name => 'ruby')]
+    xml = contact.to_xml
+    assert_match %r{<tags type="array">}, xml
+    assert_match %r{<id>#{contact.tags[0].id}</id>}, xml
+    assert_match %r{<id>#{contact.tags[1].id}</id>}, xml
+    assert_match %r{<name>awesome</name>}, xml
+    assert_match %r{<name>ruby</name>}, xml
+  end
+
+  should "include dynamic attributes" do
+    contact = Contact.new(:name => 'John', :age => 27, :foo => 'bar')
+    contact['smell'] = 'stinky'
+    assert_match %r{<smell>stinky</smell>}, contact.to_xml
+  end
+end

data/test/unit/test_clone.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+class CloneTest < Test::Unit::TestCase
+  context "Document" do
+    setup do
+      @document = Doc()
+      @embedded = EDoc()
+      @document.many :widgets, :class => @embedded
+      @tags = ['red', 'green', 'blue']
+      @doc = @document.create({
+        :name    => "foo",
+        :age     => 27,
+        :tags    => @tags,
+        :widgets => [@embedded.new, @embedded.new],
+      })
+    end
+
+    context "#clone" do
+      should "be new" do
+        @doc.clone.should be_new
+      end
+
+      should "copy the attributes" do
+        clone = @doc.clone
+        clone.name.should == "foo"
+        clone.age.should == 27
+      end
+
+      should "clone duplicable attributes" do
+        @doc.clone.tags.should_not equal(@tags)
+      end
+
+      should "clone many embedded documents" do
+        @doc.clone.widgets.object_id.should_not equal(@doc.widgets.object_id)
+      end
+
+      should "not be destroyed" do
+        @doc.destroy
+        @doc.clone.should_not be_destroyed
+      end
+    end
+  end
+
+  context "EmbeddedDocument" do
+    setup do
+      @document = EDoc do
+        key :name, String
+        key :age, Integer
+      end
+    end
+
+    context "#clone" do
+      should "regenerate the id" do
+        doc = @document.new(:name => "foo", :age => 27)
+        doc_id = doc.id
+        clone = doc.clone
+        clone_id = clone.id
+        clone_id.should_not == doc_id
+      end
+
+      should "copy the attributes" do
+        doc = @document.new(:name => "foo", :age => 27)
+        clone = doc.clone
+        clone.name.should == "foo"
+        clone.age.should == 27
+      end
+    end
+  end
+end

data/test/unit/test_document.rb

@@ -0,0 +1,249 @@
+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 "allow setting the collection name" do
+      @document.set_collection_name('foobar')
+      @document.collection.name.should == 'foobar'
+    end
+
+    context ".collection" do
+      should "default collection name to class name tableized" do
+        class ::Item
+          include MongoMapper::Document
+        end.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.collection.name.should == 'bloggy_poo.posts'
+        end
+      end
+
+      should "be an instance of a Mongo::Collection" do
+        @document.collection.should be_instance_of(Mongo::Collection)
+      end
+    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 "respond to cache_key" do
+      @document.new.should respond_to(:cache_key)
+    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 = silence_stderr { @document.new }
+        doc.id = '1234'
+        doc.new?.should be_true
+      end
+    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
+
+    context "nil attributes" do
+
+      should "list all the keys and default non nil attributes" do
+       doc = @document.new
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id']
+      end
+
+      should "list all the keys and non nil attributes" do
+       doc = @document.new(:name => "John")
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id','name']
+      end
+
+      should "list all the keys and pickup changed nil attributes" do
+       doc = @document.new(:name => "John")
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id','name']
+
+       doc.name = nil
+
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id']
+      end
+
+      should "list all the keys and pickup changed nil and non-nil attributes" do
+       doc = @document.new(:name => "John")
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id','name']
+
+       doc.name = nil
+       doc.age = 12
+
+       doc.keys.keys.sort.should == ['_id', 'age', 'name']
+       doc.attributes.keys.sort.should == ['_id','age']
+      end
+
+    end
+
+  end # instance of a document
+end # DocumentTest
+