jmonteiro-mongo_mapper 0.1.0

data/test/unit/test_mongo_mapper.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class Address; end
+
+class MongoMapperTest < Test::Unit::TestCase  
+  should "be able to write and read connection" do
+    conn = Mongo::Connection.new
+    MongoMapper.connection = conn
+    MongoMapper.connection.should == conn
+  end
+  
+  should "default connection to new mongo ruby driver" do
+    MongoMapper.connection = nil
+    MongoMapper.connection.should be_instance_of(Mongo::Connection)
+  end
+  
+  should "be able to write and read default database" do
+    MongoMapper.database = 'test'
+    MongoMapper.database.should be_instance_of(Mongo::DB)
+    MongoMapper.database.name.should == 'test'
+  end
+  
+  should "have document not found error" do
+    lambda {
+      MongoMapper::DocumentNotFound
+    }.should_not raise_error
+  end
+  
+  context "use_time_zone?" do
+    should "be true if Time.zone set" do
+      Time.zone = 'Hawaii'
+      MongoMapper.use_time_zone?.should be_true
+      Time.zone = nil
+    end
+    
+    should "be false if Time.zone not set" do
+      MongoMapper.use_time_zone?.should be_false
+    end
+  end
+  
+  context "time_class" do
+    should "be Time.zone if using time zones" do
+      Time.zone = 'Hawaii'
+      MongoMapper.time_class.should == Time.zone
+      Time.zone = nil
+    end
+    
+    should "be Time if not using time zones" do
+      MongoMapper.time_class.should == Time
+    end
+  end
+  
+  context "normalize_object_id" do
+    should "turn string into object id" do
+      id = Mongo::ObjectID.new
+      MongoMapper.normalize_object_id(id.to_s).should == id
+    end
+    
+    should "leave object id alone" do
+      id = Mongo::ObjectID.new
+      MongoMapper.normalize_object_id(id).should == id
+    end
+  end
+  
+end

data/test/unit/test_pagination.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+class PaginationTest < Test::Unit::TestCase
+  should "default per_page to 25" do
+    Doc().per_page.should == 25
+  end
+  
+  should "allow overriding per_page" do
+    Doc() { def self.per_page; 1 end }.per_page.should == 1
+  end
+  
+  context "Pagination proxy" do
+    include MongoMapper::Plugins::Pagination
+    
+    should "should have accessors for subject" do
+      subject = [1,2,3,4,5]
+      collection = PaginationProxy.new(25, 2)
+      collection.subject = subject
+      collection.subject.should == subject
+    end
+    
+    should "delegate any methods not defined to the subject" do
+      subject = [1,2,3,4,5]
+      collection = PaginationProxy.new(25, 2, 10)
+      collection.subject = subject
+      collection.size.should == 5
+      collection.each_with_index do |value, i|
+        value.should == subject[i]
+      end
+      collection[0..2].should == [1,2,3]
+      collection.class.should == Array
+    end
+    
+    should "return correct value for total_entries" do
+      PaginationProxy.new(25, 2, 10).total_entries.should == 25
+      PaginationProxy.new('25', 2, 10).total_entries.should == 25
+    end
+    
+    should "return correct value for per_page" do
+      PaginationProxy.new(25, 2, 10).per_page.should == 10
+      PaginationProxy.new(25, 2, '10').per_page.should == 10
+    end
+    
+    should "alias limit to per_page" do
+      PaginationProxy.new(100, 1, 300).limit.should == 300
+    end
+    
+    should "set per_page to 25 if nil or blank" do
+      PaginationProxy.new(25, 2).per_page.should == 25
+      PaginationProxy.new(25, 2, '').per_page.should == 25
+    end
+    
+    should "return correct value for current_page" do
+      PaginationProxy.new(25, 2, 10).current_page.should == 2
+      PaginationProxy.new(25, '2', 10).current_page.should == 2
+    end
+    
+    should "not allow value less than 1 for current page" do
+      PaginationProxy.new(25, -1).current_page.should == 1
+    end
+    
+    should "automatically calculate total_pages from total_entries and per page" do
+      PaginationProxy.new(25, 2, 10).total_pages.should == 3
+    end
+    
+    should "know how many records to skip" do
+      PaginationProxy.new(25, 2, 10).skip.should == 10
+    end
+    
+    should "alias offset to skip" do
+      PaginationProxy.new(25, 2, 10).offset.should == 10
+    end
+    
+    should "return true for === Array" do
+      collection = PaginationProxy.new(25, 2, 10)
+      collection.subject = [1, 2]
+      collection.should === Array
+    end
+        
+    context "previous_page" do
+      should "be nil if current page 1" do
+        PaginationProxy.new(25, 1, 10).previous_page.should be_nil
+      end
+      
+      should "be one less than current page if current is > 1" do
+        PaginationProxy.new(25, 2, 10).previous_page.should == 1
+      end
+    end
+    
+    context "next_page" do
+      should "be nil if current page is last page" do
+        PaginationProxy.new(25, 3, 10).next_page.should be_nil
+      end
+      
+      should "work for any page that is not last" do
+        PaginationProxy.new(25, 1, 10).next_page.should == 2
+        PaginationProxy.new(25, 2, 10).next_page.should == 3
+      end
+    end
+    
+    context "previous_page" do
+      should "be nil if current page is first page" do
+        PaginationProxy.new(25, 1, 10).previous_page.should be_nil
+      end
+      
+      should "work for any page other than first" do
+        PaginationProxy.new(25, 2, 10).previous_page.should == 1
+        PaginationProxy.new(25, 3, 10).previous_page.should == 2
+      end
+    end
+    
+    context "out_of_bounds?" do
+      should "be true if current_page is greater than total_pages" do
+        PaginationProxy.new(25, 10, 4).out_of_bounds?.should be_true
+      end
+      
+      should "be false if current_page is less than total_pages" do
+        PaginationProxy.new(25, 10, 1).out_of_bounds?.should be_false
+        PaginationProxy.new(25, 2, 10).out_of_bounds?.should be_false
+      end
+      
+      should "be false if current_page is equal to total_pages" do
+        PaginationProxy.new(25, 3, 10).out_of_bounds?.should be_false
+      end
+    end
+  end # end of pagination proxy
+end # end of test case

data/test/unit/test_plugins.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module MyPlugin
+  module ClassMethods
+    def class_foo
+      'class_foo'
+    end
+  end
+  
+  module InstanceMethods
+    def instance_foo
+      'instance_foo'
+    end
+  end
+end
+
+class PluginsTest < Test::Unit::TestCase
+  context "plugin" do
+    setup do
+      @document = Class.new do
+        extend MongoMapper::Plugins
+        plugin MyPlugin
+      end
+    end
+
+    should "include instance methods" do
+      @document.new.instance_foo.should == 'instance_foo'
+    end
+    
+    should "extend class methods" do
+      @document.class_foo.should == 'class_foo'
+    end
+    
+    should "default plugins to empty array" do
+      Class.new { extend MongoMapper::Plugins }.plugins.should == []
+    end
+    
+    should "add plugin to plugins" do
+      @document.plugins.should include(MyPlugin)
+    end
+  end
+end

data/test/unit/test_rails.rb

@@ -0,0 +1,139 @@
+require 'test_helper'
+
+class TestRails < Test::Unit::TestCase
+  context "Document" do
+    setup do
+      @klass = Doc('Post') do
+        key :foo, String
+      end
+    end
+    
+    context "Class methods" do
+      should "alias has_many to many" do
+        @klass.should respond_to(:has_many)
+      end
+
+      should "alias has_one to one" do
+        @klass.should respond_to(:has_one)
+      end
+      
+      should "have column names" do
+        @klass.column_names.sort.should == ['_id', 'foo']
+      end
+      
+      should "implement self_and_descendants" do
+        @klass.self_and_descendants.should == [@klass]
+      end
+
+      should "implement human_name" do
+        @klass.human_name.should == 'Post'
+      end
+
+      should "implement human_attribute_name" do
+        @klass.human_attribute_name(:foo).should == 'Foo'
+      end
+    end
+    
+    context "Instance methods" do
+      setup do
+        @klass.class_eval do
+          def bar=(value)
+            write_attribute(:foo, value)
+          end
+          
+          def bar_before_typecast
+            read_attribute_before_typecast(:foo)
+          end
+          
+          def bar
+            read_attribute(:foo)
+          end
+        end
+      end
+      
+      should "alias new_record? to new?" do
+        @klass.new.should be_new_record
+      end
+      
+      should "be able to read key with read_attribute" do
+        @klass.new(:foo => 'Bar').bar.should == 'Bar'
+      end
+      
+      should "be able to read key before typecast with read_attribute_before_typecast" do
+        @klass.new(:foo => 21).bar_before_typecast.should == 21
+        @klass.new(:foo => 21).bar.should == '21'
+      end
+      
+      should "be able to write key with write_attribute" do
+        @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
+      end
+    end
+  end
+  
+  context "EmbeddedDocument" do
+    setup do
+      @klass = EDoc('Post') { key :foo, String }
+    end
+    
+    context "Class methods" do
+      should "alias has_many to many" do
+        @klass.should respond_to(:has_many)
+      end
+
+      should "alias has_one to one" do
+        @klass.should respond_to(:has_one)
+      end
+      
+      should "have column names" do
+        @klass.column_names.sort.should == ['_id', 'foo']
+      end
+      
+      should "implement self_and_descendants" do
+        @klass.self_and_descendants.should == [@klass]
+      end
+      
+      should "implement human_name" do
+        @klass.human_name.should == 'Post'
+      end
+      
+      should "implement human_attribute_name" do
+        @klass.human_attribute_name(:foo).should == 'Foo'
+      end
+    end
+    
+    context "Instance methods" do
+      setup do
+        @klass.class_eval do
+          def bar=(value)
+            write_attribute(:foo, value)
+          end
+          
+          def bar_before_typecast
+            read_attribute_before_typecast(:foo)
+          end
+          
+          def bar
+            read_attribute(:foo)
+          end
+        end
+      end
+      
+      should "alias new_record? to new?" do
+        @klass.new.should be_new_record
+      end
+      
+      should "be able to read key with read_attribute" do
+        @klass.new(:foo => 'Bar').bar.should == 'Bar'
+      end
+      
+      should "be able to read key before typecast with read_attribute_before_typecast" do
+        @klass.new(:foo => 21).bar_before_typecast.should == 21
+        @klass.new(:foo => 21).bar.should == '21'
+      end
+      
+      should "be able to write key with write_attribute" do
+        @klass.new(:bar => 'Setting Foo').foo.should == 'Setting Foo'
+      end
+    end
+  end
+end

data/test/unit/test_rails_compatibility.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  class BigStuff
+    include MongoMapper::Document
+  end
+  
+  class Item
+    include MongoMapper::EmbeddedDocument
+    key :for_all, String
+  end
+
+  class FirstItem < Item  
+    key :first_only, String
+    many :second_items
+  end
+
+  class SecondItem < Item
+    key :second_only, String
+  end
+  
+  context "EmbeddedDocument" do    
+    should "alias many to has_many" do
+      FirstItem.should respond_to(:has_many)
+    end
+    
+    should "alias one to has_one" do
+      FirstItem.should respond_to(:has_one)
+    end
+    
+    should "have column names" do
+      Item.column_names.sort.should == ['_id', 'for_all']
+      FirstItem.column_names.sort.should == ['_id', 'first_only', 'for_all']
+      SecondItem.column_names.sort.should == ['_id', 'for_all', 'second_only']
+    end
+    
+    should "alias new to new_record?" do
+      instance = Item.new
+      instance.new_record?.should == instance.new?
+    end
+  end
+end

data/test/unit/test_serialization.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class SerializationTest < Test::Unit::TestCase
+  def setup
+    @document = EDoc do
+      key :name, String
+      key :age, Integer
+      key :awesome, Boolean
+      key :preferences, Hash
+      key :created_at, Time
+    end
+    
+    @instance = @document.new(
+      :name        => 'John Doe',
+      :age         => 25,
+      :awesome     => true,
+      :preferences => {:language => 'Ruby'},
+      :created_at  => Time.now.change(:usec => 0)
+    )
+  end
+  
+  [:json].each do |format|
+    context format do
+      should "be reversable" do
+        serialized = @instance.send("to_#{format}")
+        unserialized = @document.new.send("from_#{format}", serialized)
+
+        assert_equal @instance, unserialized
+      end
+      
+      should "allow attribute only filtering" do
+        serialized = @instance.send("to_#{format}", :only => [ :age, :name ])
+        unserialized = @document.new.send("from_#{format}", serialized)
+
+        assert_equal @instance.name, unserialized.name
+        assert_equal @instance.age, unserialized.age
+        assert ! unserialized.awesome
+        assert_nil unserialized.created_at
+      end
+      
+      should "allow attribute except filtering" do
+        serialized = @instance.send("to_#{format}", :except => [ :age, :name ])
+        unserialized = @document.new.send("from_#{format}", serialized)
+        
+        assert_nil unserialized.name
+        assert_nil unserialized.age
+        assert_equal @instance.awesome, unserialized.awesome
+      end
+    end
+  end
+end