fcoury-mongomapper 0.2.0

data/test/test_key.rb

@@ -0,0 +1,200 @@
+require 'test_helper'
+
+class Address
+  include MongoMapper::EmbeddedDocument
+
+  key :address, String
+  key :city,    String
+  key :state,   String
+  key :zip,     Integer
+end
+
+class KeyTest < Test::Unit::TestCase
+  include MongoMapper
+
+  context "The Key Class" do
+    should "have the native types defined" do
+      Key::NativeTypes.should == [String, Float, Time, Integer, Boolean, Array, Hash, Ref]
+    end
+  end
+
+  context "Initializing a new key" do
+    should "allow setting the name" do
+      Key.new(:foo, String).name.should == 'foo'
+    end
+
+    should "allow setting the type" do
+      Key.new(:foo, Integer).type.should be(Integer)
+    end
+
+    should "allow setting options" do
+      Key.new(:foo, Integer, :required => true).options[:required].should be(true)
+    end
+
+    should "symbolize option keys" do
+      Key.new(:foo, Integer, 'required' => true).options[:required].should be(true)
+    end
+  end
+
+  context "A key" do
+    should "be equal to another key with same name and type" do
+      Key.new(:name, String).should == Key.new(:name, String)
+    end
+
+    should "not be equal to another key with different name" do
+      Key.new(:name, String).should_not == Key.new(:foo, String)
+    end
+
+    should "not be equal to another key with different type" do
+      Key.new(:name, String).should_not == Key.new(:name, Integer)
+    end
+
+    should "know if it is native" do
+      Key.new(:name, String).native?.should be_true
+    end
+
+    should "know if it is not native" do
+      klass = Class.new
+      Key.new(:name, klass).native?.should be_false
+    end
+
+    should "know if it is a embedded_document" do
+      klass = Class.new do
+        include MongoMapper::EmbeddedDocument
+      end
+      Key.new(:name, klass).embedded_document?.should be_true
+    end
+
+    should "know if it is not a embedded_document" do
+      Key.new(:name, String).embedded_document?.should be_false
+    end
+  end
+
+  context "setting a value" do
+    should "correctly typecast Strings" do
+      key = Key.new(:foo, String)
+      [21, '21'].each do |a|
+        key.set(a).should == '21'
+      end
+    end
+
+    should "correctly typecast Integers" do
+      key = Key.new(:foo, Integer)
+      [21, 21.0, '21'].each do |a|
+        key.set(a).should == 21
+      end
+    end
+
+    should "correctly typecast Floats" do
+      key = Key.new(:foo, Float)
+      [21, 21.0, '21'].each do |a|
+        key.set(a).should == 21.0
+      end
+    end
+
+    should "correctly typecast Times" do
+      key = Key.new(:foo, Time)
+      key.set('2000-01-01 01:01:01.123456').should == Time.local(2000, 1, 1, 1, 1, 1, 123456)
+    end
+
+    should_eventually "correctly typecast Dates" do
+      key = Key.new(:foo, Date)
+      key.set('2000-01-01').should == Date.new(2000, 1, 1)
+    end
+
+    should "correctly typecast Boolean" do
+      key = Key.new(:foo, Boolean)
+      ['false', false, 'f', '0', 0].each do |b|
+        key.set(b).should == false
+      end
+
+      ['true', true, 't', '1', 1].each do |b|
+        key.set(b).should == true
+      end
+    end
+
+    should "correctly typecast Array" do
+      key = Key.new(:foo, Array)
+      key.set([1,2,3,4]).should == [1,2,3,4]
+      key.set({'1' => '2', '3' => '4'}).should == [['1', '2'], ['3', '4']]
+      key.set('1').should == ['1']
+    end
+
+    should "correctly typecast Hash using indifferent access" do
+      key = Key.new(:foo, Hash)
+      key.set(:foo => 'bar')[:foo].should == 'bar'
+      key.set(:foo => 'bar')['foo'].should == 'bar'
+      key.set(:foo => {:bar => 'baz'})[:foo][:bar].should == 'baz'
+      key.set(:foo => {:bar => 'baz'})['foo']['bar'].should == 'baz'
+    end
+  end
+
+  context "getting a value" do
+    should "work" do
+      key = Key.new(:foo, String)
+      key.get('bar').should == 'bar'
+    end
+
+    context "for a key with a default value set" do
+      setup do
+        @key = Key.new(:foo, String, :default => 'baz')
+      end
+
+      should "return default value if value nil" do
+        @key.get(nil).should == 'baz'
+      end
+
+      should "return value if not blank" do
+        @key.get('foobar').should == 'foobar'
+      end
+    end
+
+    context "for a boolean key" do
+      should "allow setting default to false" do
+        Key.new(:active, Boolean, :default => false).get(nil).should be_false
+      end
+
+      should "allow setting default to true" do
+        Key.new(:active, Boolean, :default => true).get(nil).should be_true
+      end
+    end
+
+    context "for an array" do
+      should "return array" do
+        key = Key.new(:foo, Array)
+        key.get([1,2]).should == [1,2]
+      end
+
+      should "default to empty array" do
+        key = Key.new(:foo, Array)
+        key.get(nil).should == []
+      end
+    end
+
+    context "for a hash" do
+      should "default to empty hash" do
+        key = Key.new(:foo, Hash)
+        key.get(nil).should == {}
+      end
+
+      should "use hash with indifferent access" do
+        key = Key.new(:foo, Hash)
+        key.get({:foo => 'bar'})['foo'].should == 'bar'
+        key.get({:foo => 'bar'})[:foo].should == 'bar'
+      end
+    end
+
+    context "for a embedded_document" do
+      should "default to nil" do
+        key = Key.new(:foo, Address)
+        key.get(nil).should be_nil
+      end
+
+      should "return instance if instance" do
+        address = Address.new(:city => 'South Bend', :state => 'IN', :zip => 46544)
+        key = Key.new(:foo, Address)
+        key.get(address).should == address
+      end
+    end
+  end
+end # KeyTest

data/test/test_mongomapper.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class Address; end
+
+class MongoMapperTest < Test::Unit::TestCase  
+  should "be able to write and read connection" do
+    conn = XGen::Mongo::Driver::Mongo.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(XGen::Mongo::Driver::Mongo)
+  end
+  
+  should "be able to write and read default database" do
+    MongoMapper.database = DefaultDatabase
+    MongoMapper.database.should be_instance_of(XGen::Mongo::Driver::DB)
+    MongoMapper.database.name.should == DefaultDatabase
+  end
+  
+  should "have document not found error" do
+    lambda {
+      MongoMapper::DocumentNotFound
+    }.should_not raise_error
+  end
+end

data/test/test_observing.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+class Comment
+  include MongoMapper::Document
+  
+  key :name, String
+  key :body, String
+  
+  attr_accessor :callers
+  before_validation :record_callers
+
+  def after_validation
+    record_callers
+  end
+
+  def record_callers
+    callers << self.class if callers
+  end
+end
+
+class Article
+  include MongoMapper::Document
+  
+  key :title, String
+  key :body, String
+end
+
+class CommentObserver < MongoMapper::Observer
+  attr_accessor :callers
+
+  def after_validation(model)
+    callers << self.class if callers
+  end
+end
+
+class AuditObserver < MongoMapper::Observer
+  observe Article, Comment
+  attr_reader :document
+  
+  def after_validation(document)
+    @document = document
+  end
+end
+
+class GlobalObserver < MongoMapper::Observer
+  observe Article, Comment
+  attr_reader :document
+  
+  def before_save(document)
+    @document = document
+  end
+end
+
+class NonAutomaticObserver < MongoMapper::Observer
+  observe Comment
+  attr_reader :comment
+  
+  def after_validation(comment)
+    @comment = comment
+  end
+end
+
+class ObserverTest < Test::Unit::TestCase  
+  should "fire model callbacks before observer" do
+    callers = []
+    comment = Comment.new
+    comment.callers = callers
+
+    CommentObserver.instance.callers = callers
+
+    comment.valid?
+    callers.should == [Comment, Comment, CommentObserver]
+  end
+  
+  should "automatically observe model based on name when possible" do
+    CommentObserver.observed_class.should == Comment
+  end
+  
+  should "be able to observe other models using observe" do
+    obs = NonAutomaticObserver.instance
+    comment = Comment.new(:name => 'John Nunemaker', :body => 'is awesome')
+    comment.valid?
+    obs.comment.name.should == 'John Nunemaker'
+    obs.comment.body.should == 'is awesome'
+  end
+  
+  should "be able to observe multiple models" do
+    obs = AuditObserver.instance
+    comment = Comment.new(:name => 'Steve Smith', :body => 'is awesome')
+    comment.valid?
+    
+    obs.document.name.should == 'Steve Smith'
+    obs.document.body.should == 'is awesome'
+    
+    article = Article.new(:title => 'Ordered List Is Awesome', :body => 'Learn to accept it!')
+    article.valid?
+    
+    obs.document.title.should == 'Ordered List Is Awesome'
+    obs.document.body.should == 'Learn to accept it!'
+  end
+end

data/test/test_rails_compatibility.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class Item
+  include MongoMapper::EmbeddedDocument
+  key :for_all, String
+end
+
+class FirstItem < Item  
+  key :first_only, String
+end
+
+class SecondItem < Item
+  key :second_only, String
+end
+
+class Order
+  include MongoMapper::Document
+  many :items, :polymorphic => true, :class_name => "Item"
+  key :order_only, String
+end
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  def setup
+    @document = Class.new do
+      include MongoMapper::Document
+    end
+  end
+  
+  context "EmbeddedDocument" do
+    should "have to_param that returns id" do
+      first_item = FirstItem.new
+      second_item = SecondItem.new
+
+      order = Order.create('_id' => '1234')
+      order.items = [
+        first_item,
+        second_item
+      ]
+      order.to_param.should == '1234'
+
+      lambda { first_item.to_param }.should raise_error
+      lambda { second_item.to_param }.should raise_error
+    end
+
+    should "have column names" do
+      Order.column_names.sort.should == ['_id', 'created_at', 'order_only', 'updated_at']
+      FirstItem.column_names.sort.should == ['first_only', 'for_all']
+      SecondItem.column_names.sort.should == ['for_all', 'second_only']
+    end
+  end
+
+  context "Document" do
+    should "have to_param that returns id" do
+      instance = @document.create('_id' => '1234')
+      instance.to_param.should == '1234'
+    end
+
+    should "alias new to new_record?" do
+      instance = @document.new
+      instance.new_record?.should == instance.new?
+    end
+
+    should "alias many to has_many" do
+      @document.should respond_to(:has_many)
+      @document.method(:has_many).should == @document.method(:many)
+    end
+
+    should "have column names" do
+      @document.key :fname, String
+      @document.column_names.sort.should == ['_id', 'created_at', 'fname', 'updated_at']
+    end
+  end
+end

data/test/test_serializations.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class SerializationTest < Test::Unit::TestCase
+  def setup
+    @document = Class.new do
+      include MongoMapper::EmbeddedDocument
+      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
+  
+  # [:xml, :json].each do |format|
+  [: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_nil 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