mongomatic 0.6.2 → 0.6.3

data/test/helper.rb

@@ -1,6 +1,5 @@
 require 'rubygems'
-require 'test/unit'
-require 'shoulda'
+gem 'minitest', "~> 2.0"
 require 'pp'
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -88,5 +87,19 @@ class Person < Mongomatic::Base
   
 end
 
-class Test::Unit::TestCase
+class Thing < Mongomatic::Base
+  def before_insert
+    raise NoMethodError
+  end
+
+  def self.before_drop
+    raise NoMethodError
+  end
+end
+
+class Foobar < Mongomatic::Base
+  def validate
+    errors << ["color", "must not be blank"] if self["color"].blank?
+    errors << "missing style" if self["style"].blank?
+  end
 end

data/test/test_exceptions.rb

@@ -1,36 +1,37 @@
 require 'helper'
+require 'minitest/autorun'
 
-class TestExceptions < Test::Unit::TestCase
+class TestExceptions < MiniTest::Unit::TestCase
   def setup
     Person.collection.drop
   end
   
-  should "raise on updating new document" do
+  def test_raise_on_update_of_new_doc
     p1 = Person.new(:name => "Jordan")
     assert_equal false, p1.update
-    assert_raise(Mongomatic::Exceptions::DocumentIsNew) { p1.update(:raise => true) }
+    assert_raises(Mongomatic::Exceptions::DocumentIsNew) { p1.update(:raise => true) }
   end
   
-  should "raise on inserting invalid document" do
+  def test_raise_on_insert_of_invalid_doc
     p1 = Person.new
     assert_equal false, p1.insert
-    assert_raise(Mongomatic::Exceptions::DocumentNotValid) { p1.insert(:raise => true) }
+    assert_raises(Mongomatic::Exceptions::DocumentNotValid) { p1.insert(:raise => true) }
   end
   
-  should "raise on updating invalid document" do
+  def test_raise_on_update_of_invalid_doc
     p1 = Person.new(:name => "Ben")
     assert p1.insert
     p1["name"] = nil
     assert_equal false, p1.update
-    assert_raise(Mongomatic::Exceptions::DocumentNotValid) { p1.update(:raise => true) }
+    assert_raises(Mongomatic::Exceptions::DocumentNotValid) { p1.update(:raise => true) }
   end
   
-  should "raise on remove" do
+  def test_raise_on_update_or_insert_after_remove
     p1 = Person.new(:name => "Ben")
     assert p1.insert
     assert p1.remove
-    assert_raise(Mongomatic::Exceptions::DocumentWasRemoved) { p1.remove(:raise => true) }
-    assert_raise(Mongomatic::Exceptions::DocumentWasRemoved) { p1.update(:raise => true) }
-    assert_raise(Mongomatic::Exceptions::DocumentWasRemoved) { p1.insert(:raise => true) }
+    assert_raises(Mongomatic::Exceptions::DocumentWasRemoved) { p1.remove(:raise => true) }
+    assert_raises(Mongomatic::Exceptions::DocumentWasRemoved) { p1.update(:raise => true) }
+    assert_raises(Mongomatic::Exceptions::DocumentWasRemoved) { p1.insert(:raise => true) }
   end
 end

data/test/test_find.rb

@@ -0,0 +1,81 @@
+require 'helper'
+require 'minitest/autorun'
+
+class TestFind < MiniTest::Unit::TestCase
+  def test_find_one_with_query
+    Person.collection.drop
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    
+    assert_equal p1, Person.find_one(:name => "Jordan")
+  end
+  
+  def test_find_one_with_id
+    Person.collection.drop
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    
+    assert_equal p1, Person.find_one(p1['_id'])
+  end
+  
+  def test_find_one_with_id_or_hash
+    Person.collection.drop
+    Person.create_indexes
+    
+    p = Person.new(:name => "Ben1", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+    assert p.insert!.is_a?(BSON::ObjectId)
+    assert_equal 1, Person.count
+    
+    found = Person.find({"_id" => BSON::ObjectId(p["_id"].to_s)}).next
+    assert_equal found, p
+    
+    assert_raises(TypeError) { Person.find_one(p["_id"].to_s) }
+    
+    found = Person.find_one({"_id" => p["_id"].to_s})
+    assert_equal found, nil
+    
+    found = Person.find_one({"_id" => BSON::ObjectId(p["_id"].to_s)})
+    assert_equal found, p
+  end
+  
+  def test_limit_and_sort
+    Person.collection.drop
+    p = Person.new(:name => "Ben", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+    assert p.insert.is_a?(BSON::ObjectId)
+    assert_equal 1, Person.collection.count
+    p2 = Person.new(:name => "Ben2", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+    assert p2.insert.is_a?(BSON::ObjectId)
+    assert_equal 2, Person.collection.count
+    
+    cursor = Person.find({"_id" => p["_id"]})
+    found  = cursor.next
+    assert_equal p, found
+    
+    cursor = Person.find()
+    assert_equal 0, cursor.current_limit
+    assert_equal 2, cursor.to_a.size
+    cursor = Person.find().limit(1)
+    assert_equal 1, cursor.current_limit
+    assert_equal 1, cursor.to_a.size
+    cursor = Person.find().limit(1)
+    assert_equal p, cursor.next
+    assert_equal nil, cursor.next
+    cursor = Person.find().limit(1).skip(1)
+    assert_equal p2, cursor.next
+
+    cursor = Person.find().sort("name", Mongo::ASCENDING)
+    assert_equal p, cursor.next
+
+    cursor = Person.find().sort("name", Mongo::DESCENDING)
+    assert_equal p2, cursor.next
+  end
+  
+  def test_instance_of_class_returned_on_find_one
+    Person.collection.drop
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    
+    assert_equal Person, Person.find_one(:name => "Jordan").class
+  end
+  
+end

data/test/test_misc.rb

@@ -0,0 +1,190 @@
+require 'helper'
+require 'minitest/autorun'
+
+class TestMisc < MiniTest::Unit::TestCase
+  def test_keys_can_be_strings_or_symbols
+    Person.collection.drop
+    p1 = Person.new(:name => "Jordan")
+    p1[:address] = { :city => "San Francisco" }
+    assert_equal "Jordan", p1["name"]
+    assert_equal "Jordan", p1[:name]
+    assert_equal "San Francisco", p1["address"]["city"]
+    assert_equal "San Francisco", p1[:address][:city]
+    p1.insert
+    
+    p1 = Person.find_one(:name => "Jordan")
+    assert_equal "Jordan", p1["name"]
+    assert_equal "Jordan", p1[:name]
+    assert_equal "San Francisco", p1["address"]["city"]
+    assert_equal "San Francisco", p1[:address][:city]
+  end
+  
+  def test_empty_cursor
+    Person.collection.drop
+    assert Person.empty?
+    assert Person.find.empty?
+    p1 = Person.new(:name => "Jordan")
+    p1.insert
+    assert !Person.empty?
+    assert !Person.find.empty?
+    assert !Person.find({"name" => "Jordan"}).empty?
+    assert Person.find({"name" => "Ben"}).empty?
+    p1.remove!
+    assert Person.empty?
+    assert Person.find.empty?
+    assert Person.find({"name" => "Jordan"}).empty?
+  end
+  
+  def test_enumerable
+    Person.collection.drop
+    p1 = Person.new(:name => "Ben1", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+    p2 = Person.new(:name => "Ben2", :birth_year => 1986, :created_at => Time.now.utc, :admin => true)
+    assert p1.insert.is_a?(BSON::ObjectId)
+    assert p2.insert.is_a?(BSON::ObjectId)
+    assert_equal 2, Person.collection.count
+    assert_equal 2, Person.find.inject(0) { |sum, p| assert p.is_a?(Person); sum += 1 }
+    assert_equal p2, Person.find.max { |p1,p2| p1["birth_year"] <=> p2["birth_year"] }
+  end
+  
+  def test_enumerable_cursor
+    Person.collection.drop
+    1000.upto(2000) do |i|
+      p = Person.new(:name => "Ben#{i}", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+      assert p.insert.is_a?(BSON::ObjectId)
+    end
+    i = 1000
+    Person.find().sort(["name", :asc]).each { |p| assert_equal "Ben#{i}", p["name"]; i += 1 }
+    Person.find().sort(["name", :asc]).each_with_index { |p,i| assert_equal "Ben#{1000+i}", p["name"] }
+    
+    p = Person.find().limit(1).next
+    assert Person.find().sort(["name", :asc]).include?(p)
+    
+    assert_equal 10, Person.find().limit(10).to_a.size
+  end
+  
+  def test_merging_hashes
+    Person.collection.drop
+    p = Person.new(:name => "Ben", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+    assert p.insert.is_a?(BSON::ObjectId)
+    assert_equal 1, Person.collection.count
+    p.merge(:birth_year => 1986)
+    p.update
+    p = Person.find({"_id" => p["_id"]}).next
+    assert_equal 1986, p["birth_year"]
+  end
+  
+  def test_callbacks
+    p = Person.new(:name => "Ben1", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+    p.callback_tests = []
+    assert p.callback_tests.empty?
+    assert p.valid?
+    assert_equal [:before_validate, :after_validate], p.callback_tests
+    p.callback_tests = []
+    assert p.insert.is_a?(BSON::ObjectId)
+    assert_equal [:before_validate, :after_validate,  :before_insert, :before_insert_or_update, :after_insert, :after_insert_or_update], p.callback_tests
+    p.callback_tests = []
+    p.update
+    assert_equal [:before_validate, :after_validate, :before_update, :before_insert_or_update, :after_update, :after_insert_or_update], p.callback_tests
+    p.callback_tests = []
+    p.remove
+    assert_equal [:before_remove, :after_remove], p.callback_tests
+    Person.class_callbacks = []
+    Person.drop
+    assert_equal [:before_drop, :after_drop], Person.class_callbacks
+  end
+  
+  def test_unique_index
+    Person.collection.drop
+    Person.create_indexes
+    
+    p = Person.new(:name => "Ben1", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+    assert p.insert!.is_a?(BSON::ObjectId)
+    assert_equal 1, Person.count
+    
+    p = Person.new(:name => "Ben1", :birth_year => 1984, :created_at => Time.now.utc, :admin => true)
+    assert_raises(Mongo::OperationFailure) { p.insert! }
+    
+    assert_equal 1, Person.count
+  end
+  
+  def test_is_new_flag
+    Person.collection.drop
+    p = Person.new
+    assert p.is_new?
+    assert !p.insert
+    assert p.is_new?
+    p["name"] = "Ben"
+    assert p.insert
+    assert !p.is_new?
+    p = Person.find_one(p["_id"])
+    assert !p.is_new?
+  end
+  
+  def test_custom_id
+    Person.collection.drop
+    p = Person.new(:name => "Ben")
+    assert p.is_new?
+    p["_id"] = "mycustomid"
+    assert p.insert
+    found = Person.find_one({"_id" => "mycustomid"})
+    assert_equal found, p
+    assert !p.is_new?
+    found["age"] = 26
+    assert found.update
+    found = Person.find_one({"_id" => "mycustomid"})
+    assert_equal found["_id"], "mycustomid"
+    assert_equal 26, found["age"]
+  end
+  
+  def test_be_able_to_drop_collection
+    p = Person.new
+    p['name'] = "Jordan"
+    p.insert
+
+    assert !Person.empty?
+
+    Person.drop
+    assert Person.empty?
+  end
+  
+  def test_has_key_with_symbols_and_strings
+    p = Person.new
+    
+    assert !p.has_key?(:name)
+    
+    p['name'] = 'Jordan'
+    
+    assert p.has_key?(:name)
+    assert p.has_key?('name')
+  end
+  
+  def test_has_key
+    p = Person.new(:employer => {:name => 'Meta+Level Games', 
+                                 :function => 'Makes things with code', 
+                                 :something_else => {
+                                   :with_a_key => 'And Value'}
+                                 })
+                                 
+    assert !p.has_key?('employer.started_at')
+    assert p.has_key?('employer.name')
+    assert !p.has_key?('non.existent')
+    assert !p.has_key?('employer.something_else.not_here')
+    assert p.has_key?('employer.something_else.with_a_key')
+  end
+  
+  def test_value_for_key
+    p = Person.new(:employer => {:name => 'Meta+Level Games', 
+                                 :function => 'Makes things with code', 
+                                 :something_else => {
+                                   :with_a_key => 'And Value'}
+                                 })
+    assert_equal "And Value", p.value_for_key("employer.something_else.with_a_key")
+    assert_equal "Meta+Level Games", p.value_for_key("employer.name")
+    assert_nil p.value_for_key("some_key.that_does_not.exist")
+  end
+  
+  def test_no_method_error_in_callback
+    assert_raises(NoMethodError) { Thing.new.insert }
+    assert_raises(NoMethodError) { Thing.drop }
+  end
+end

data/test/test_modifiers.rb

@@ -1,11 +1,12 @@
 require 'helper'
+require 'minitest/autorun'
 
-class TestModifiers < Test::Unit::TestCase
+class TestModifiers < MiniTest::Unit::TestCase
   def setup
     Person.collection.drop
   end
   
-  should "be able to push" do
+  def test_push
     p1 = Person.new(:name => "Jordan")
     p1.insert
     assert p1.push("interests", "skydiving")
@@ -18,10 +19,10 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["skydiving","coding"], p1["interests"]
     
     p1["interests"] = "foo"
-    assert_raise(Mongomatic::Modifiers::UnexpectedFieldType) { p1.push("interests", "snowboarding") }
+    assert_raises(Mongomatic::Modifiers::UnexpectedFieldType) { p1.push("interests", "snowboarding") }
   end
   
-  should "be able to push on a field in an embedded hash" do
+  def test_push_into_embedded_hash
     p1 = Person.new(:name => "Jordan")
     p1.insert
     assert p1.push!("personal.interests", "skydiving")
@@ -30,7 +31,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["skydiving"], p1["personal"]["interests"]
   end
   
-  should "be able to push_all" do
+  def test_push_all
     p1 = Person.new(:name => "Jordan")
     p1.insert
     assert p1.push("interests", "skydiving")
@@ -44,10 +45,10 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["skydiving","coding","running","snowboarding","reading"], p1["interests"]
     
     p1["interests"] = "foo"
-    assert_raise(Mongomatic::Modifiers::UnexpectedFieldType) { p1.push_all("interests", ["snowboarding"]) }
+    assert_raises(Mongomatic::Modifiers::UnexpectedFieldType) { p1.push_all("interests", ["snowboarding"]) }
   end
   
-  should "be able to push_all on a field in an embedded hash" do
+  def test_push_all_in_embedded_hash
     p1 = Person.new(:name => "Jordan")
     p1.insert
     p1.push_all!("contacts.coworkers", ["Chris","Keith","Jordan","Mike"])
@@ -56,7 +57,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
   end
   
-  should "be able to pull" do
+  def test_pull
     p1 = Person.new(:name => "Jordan")
     p1.insert
     assert p1.push("interests", "skydiving")
@@ -69,10 +70,10 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["skydiving","coding","snowboarding","reading"], p1["interests"]
    
     p1["interests"] = "foo"
-    assert_raise(Mongomatic::Modifiers::UnexpectedFieldType) { p1.pull("interests", ["snowboarding"]) }
+    assert_raises(Mongomatic::Modifiers::UnexpectedFieldType) { p1.pull("interests", ["snowboarding"]) }
   end
   
-  should "be able to pull on a field in an embedded hash" do
+  def test_pull_from_embedded_hash
     p1 = Person.new(:name => "Jordan")
     p1.insert!
     p1.push_all!("contacts.coworkers", ["Chris","Keith","Jordan","Mike","Joe"])
@@ -83,7 +84,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
   end
   
-  should "be able to pull_all" do
+  def test_pull_all
     p1 = Person.new(:name => "Jordan")
     p1.insert
     assert p1.push_all!("interests", ["skydiving", "coding","running","snowboarding","reading"])
@@ -95,10 +96,10 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["skydiving", "coding","reading"], p1["interests"]
    
     p1["interests"] = "foo"
-    assert_raise(Mongomatic::Modifiers::UnexpectedFieldType) { p1.pull_all("interests", ["snowboarding"]) }
+    assert_raises(Mongomatic::Modifiers::UnexpectedFieldType) { p1.pull_all("interests", ["snowboarding"]) }
   end
   
-  should "be able to pull_all on a field in an embedded hash" do
+  def test_pull_all_from_embedded_hash
     p1 = Person.new(:name => "Jordan")
     p1.insert!
     p1.push_all!("contacts.coworkers", ["Chris","Jim","Keith","Jordan","Mike","Joe"])
@@ -109,7 +110,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["Chris","Keith","Jordan","Mike"], p1["contacts"]["coworkers"]
   end
   
-  should "be able to inc" do
+  def test_inc
     p1 = Person.new(:name => "Jordan")
     assert p1.insert!
     p1["count1"] = 5
@@ -123,7 +124,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal -4, p1["count2"]
   end
   
-  should "be able to inc a field in an embedded hash" do
+  def test_inc_in_embedded_hash
     p1 = Person.new(:name => "Jordan")
     assert p1.insert!
     p1.inc!("counters.visitors", 10)
@@ -135,7 +136,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal 20, p1["level1"]["level2"]["level3"]["counter"]
   end
   
-  should "be able to set" do
+  def test_set
     p1 = Person.new(:name => "Jordan")
     assert p1.insert!
     assert p1.set!("foo", "bar")
@@ -144,7 +145,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal "bar", p1["foo"]
   end
   
-  should "be able to set a field in an embedded hash" do
+  def test_set_in_embedded_hash
     p1 = Person.new(:name => "Jordan")
     assert p1.insert!
     p1.set!("l1.l2.l3.l4.name", "Ben")
@@ -153,7 +154,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal "Ben", p1["l1"]["l2"]["l3"]["l4"]["name"]
   end
   
-  should "be able to unset" do
+  def test_unset
     p1 = Person.new(:name => "Jordan")
     assert p1.insert!
     assert p1.set!("foo", "bar")
@@ -167,7 +168,7 @@ class TestModifiers < Test::Unit::TestCase
     assert p1["foo"].nil?
   end
   
-  should "be able to unset a field in an embedded hash" do
+  def test_unset_in_embedded_hash
     p1 = Person.new(:name => "Jordan")
     assert p1.insert!
     p1.set!("l1.l2.l3.l4.name", "Ben")
@@ -185,7 +186,7 @@ class TestModifiers < Test::Unit::TestCase
     assert !p1["l1"]["l2"]["l3"]["l4"].has_key?("name")
   end
   
-  should "be able to add_to_set" do
+  def test_add_to_set
     p1 = Person.new(:name => "Jordan")
     assert p1.insert!
     
@@ -201,7 +202,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["grey","blue"], p1["cold_colors"]
   end
   
-  should "be able to add_to_set in an embedded hash" do
+  def test_add_to_set_in_embedded_hash
     p1 = Person.new(:name => "Jordan")
     assert p1.insert!
     p1.add_to_set!("colors.hot", ["red", "pink", "orange"])
@@ -210,7 +211,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal ["red", "pink", "orange"], p1["colors"]["hot"]
   end
   
-  should "be able to pop_last" do
+  def test_pop_last
     p1 = Person.new(:name => "Jordan")
     p1["numbers"] = [1,2,3,4,5]
     assert p1.insert!
@@ -220,7 +221,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal [1,2,3,4], p1["numbers"]
   end
   
-  should "be able to pop_last in an embedded doc" do
+  def test_pop_last_in_embedded_hash
     p1 = Person.new(:name => "Jordan")
     p1["stats"] = { "numbers" => [1,2,3,4,5] }
     assert p1.insert!
@@ -230,7 +231,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal [1,2,3,4], p1["stats"]["numbers"]
   end
   
-  should "be able to pop_first" do
+  def test_pop_first
     p1 = Person.new(:name => "Jordan")
     p1["numbers"] = [1,2,3,4,5]
     assert p1.insert!
@@ -240,7 +241,7 @@ class TestModifiers < Test::Unit::TestCase
     assert_equal [2,3,4,5], p1["numbers"]
   end
   
-  should "be able to pop_first in an embedded doc" do
+  def test_pop_first_in_embedded_hash
     p1 = Person.new(:name => "Jordan")
     p1["stats"] = { "numbers" => [1,2,3,4,5] }
     assert p1.insert!

data/test/test_persistence.rb

@@ -0,0 +1,43 @@
+require 'helper'
+require 'minitest/autorun'
+
+class TestPersistence < MiniTest::Unit::TestCase
+  def test_insert_update_remove
+    Person.collection.drop
+    
+    p = Person.new
+    
+    assert !p.valid?
+    assert_equal(["name can't be empty"], p.errors.full_messages)
+    
+    p["name"] = "Ben Myles"
+    p["birth_year"] = 1984
+    p["created_at"] = Time.now.utc
+    p["admin"] = true
+    
+    assert !p.update
+    
+    assert p.insert.is_a?(BSON::ObjectId)
+    
+    assert_equal 1, Person.collection.count
+
+    cursor = Person.find({"_id" => p["_id"]})
+    found  = cursor.next
+    assert_equal p, found
+    assert_equal "Ben Myles", found["name"]
+    
+    p["name"] = "Benjamin"
+    assert p.update
+    
+    cursor = Person.find({"_id" => p["_id"]})
+    found  = cursor.next
+    assert_equal p, found
+    assert_equal "Benjamin", found["name"]
+    
+    assert p.remove
+    assert p.removed?
+    cursor = Person.find({"_id" => p["_id"]})
+    found  = cursor.next
+    assert_nil found
+  end
+end