jmonteiro-mongo_mapper 0.1.0

data/test/unit/test_dynamic_finder.rb

@@ -0,0 +1,125 @@
+require 'test_helper'
+
+class DynamicFinderTest < Test::Unit::TestCase
+  include MongoMapper
+  
+  should "initialize with method" do
+    finder = DynamicFinder.new(:foobar)
+    finder.method.should == :foobar
+  end
+  
+  context "found?" do
+    should "be true for find_by" do
+      DynamicFinder.new(:find_by_foo).found?.should be_true
+    end
+    
+    should "be true for find_by with !" do
+      DynamicFinder.new(:find_by_foo!).found?.should be_true
+    end
+    
+    should "be true for find_all_by" do
+      DynamicFinder.new(:find_all_by_foo).found?.should be_true
+    end
+    
+    should "be true for find_or_initialize_by" do
+      DynamicFinder.new(:find_or_initialize_by_foo).found?.should be_true
+    end
+    
+    should "be true for find_or_create_by" do
+      DynamicFinder.new(:find_or_create_by_foo).found?.should be_true
+    end
+    
+    should "be false for anything else" do
+      [:foobar, :bazwick].each do |method|
+        DynamicFinder.new(method).found?.should be_false
+      end
+    end
+  end
+  
+  context "find_all_by" do
+    should "parse one attribute" do
+      DynamicFinder.new(:find_all_by_foo).attributes.should == %w(foo)
+    end
+    
+    should "parse multiple attributes" do
+      DynamicFinder.new(:find_all_by_foo_and_bar).attributes.should == %w(foo bar)
+      DynamicFinder.new(:find_all_by_foo_and_bar_and_baz).attributes.should == %w(foo bar baz)
+    end
+    
+    should "set finder to :all" do
+      DynamicFinder.new(:find_all_by_foo_and_bar).finder.should == :all
+    end
+  end
+  
+  context "find_by" do
+    should "parse one attribute" do
+      DynamicFinder.new(:find_by_foo).attributes.should == %w(foo)
+    end
+    
+    should "parse multiple attributes" do
+      DynamicFinder.new(:find_by_foo_and_bar).attributes.should == %w(foo bar)
+    end
+    
+    should "set finder to :first" do
+      DynamicFinder.new(:find_by_foo).finder.should == :first
+    end
+    
+    should "set bang to false" do
+      DynamicFinder.new(:find_by_foo).bang.should be_false
+    end
+  end
+  
+  context "find_by with !" do
+    should "parse one attribute" do
+      DynamicFinder.new(:find_by_foo!).attributes.should == %w(foo)
+    end
+    
+    should "parse multiple attributes" do
+      DynamicFinder.new(:find_by_foo_and_bar!).attributes.should == %w(foo bar)
+    end
+    
+    should "set finder to :first" do
+      DynamicFinder.new(:find_by_foo!).finder.should == :first
+    end
+    
+    should "set bang to true" do
+      DynamicFinder.new(:find_by_foo!).bang.should be_true
+    end
+  end
+  
+  context "find_or_initialize_by" do
+    should "parse one attribute" do
+      DynamicFinder.new(:find_or_initialize_by_foo).attributes.should == %w(foo)
+    end
+    
+    should "parse multiple attributes" do
+      DynamicFinder.new(:find_or_initialize_by_foo_and_bar).attributes.should == %w(foo bar)
+    end
+    
+    should "set finder to :first" do
+      DynamicFinder.new(:find_or_initialize_by_foo).finder.should == :first
+    end
+    
+    should "set instantiator to new" do
+      DynamicFinder.new(:find_or_initialize_by_foo).instantiator.should == :new
+    end
+  end
+
+  context "find_or_create_by" do
+    should "parse one attribute" do
+      DynamicFinder.new(:find_or_create_by_foo).attributes.should == %w(foo)
+    end
+    
+    should "parse multiple attributes" do
+      DynamicFinder.new(:find_or_create_by_foo_and_bar).attributes.should == %w(foo bar)
+    end
+    
+    should "set finder to :first" do
+      DynamicFinder.new(:find_or_create_by_foo).finder.should == :first
+    end
+    
+    should "set instantiator to new" do
+      DynamicFinder.new(:find_or_create_by_foo).instantiator.should == :create
+    end
+  end
+end

data/test/unit/test_embedded_document.rb

@@ -0,0 +1,628 @@
+require 'test_helper'
+
+class Grandparent
+  include MongoMapper::EmbeddedDocument
+  key :grandparent, String
+end
+
+class Parent < Grandparent
+  include MongoMapper::EmbeddedDocument
+  key :parent, String
+end
+
+class Child < Parent
+  include MongoMapper::EmbeddedDocument
+  key :child, String
+end
+
+module KeyOverride
+  def other_child
+    self[:other_child] || "special result"
+  end
+  
+  def other_child=(value)
+    super(value + " modified")
+  end
+end
+
+class OtherChild < Parent
+  include MongoMapper::EmbeddedDocument
+  include KeyOverride
+  
+  key :other_child, String
+end
+
+class EmbeddedDocumentTest < Test::Unit::TestCase
+  context "Including MongoMapper::EmbeddedDocument in a class" do
+    setup do
+      @klass = EDoc()
+    end
+    
+    should "add _id key" do
+      @klass.keys['_id'].should_not be_nil
+    end
+    
+    should "know it is using object id" do
+      @klass.using_object_id?.should be_true
+    end
+    
+    should "know it is not using object id if _id type is changed" do
+      @klass.key :_id, String
+      @klass.using_object_id?.should be_false
+    end
+  end
+  
+  context "Class Methods" do
+    should "include logger" do
+      @klass = EDoc()
+      @klass.logger.should == MongoMapper.logger
+      @klass.logger.should be_instance_of(Logger)
+    end
+    
+    should "return false for embeddable" do
+      EDoc().embeddable?.should be_true
+    end
+    
+    context "#to_mongo" do
+      setup { @klass = EDoc() }
+      
+      should "be nil if nil" do
+        @klass.to_mongo(nil).should be_nil
+      end
+      
+      should "convert to_mongo for other values" do
+        doc = @klass.new(:foo => 'bar')
+        to_mongo = @klass.to_mongo(doc)
+        to_mongo.is_a?(Hash).should be_true
+        to_mongo['foo'].should == 'bar'
+      end
+    end
+    
+    context "#from_mongo" do
+      setup { @klass = EDoc() }
+      
+      should "be nil if nil" do
+        @klass.from_mongo(nil).should be_nil
+      end
+      
+      should "be instance if instance of class" do
+        doc = @klass.new
+        @klass.from_mongo(doc).should == doc
+      end
+      
+      should "be instance if hash of attributes" do
+        doc = @klass.from_mongo({:foo => 'bar'})
+        doc.instance_of?(@klass).should be_true
+        doc.foo.should == 'bar'
+      end
+    end
+
+    context "defining a key" do
+      setup do
+        @document = EDoc()
+      end
+
+      should "work with name" do
+        key = @document.key(:name)
+        key.name.should == 'name'
+      end
+
+      should "work with name and type" do
+        key = @document.key(:name, String)
+        key.name.should == 'name'
+        key.type.should == String
+      end
+
+      should "work with name, type and options" do
+        key = @document.key(:name, String, :required => true)
+        key.name.should == 'name'
+        key.type.should == String
+        key.options[:required].should be_true
+      end
+
+      should "work with name and options" do
+        key = @document.key(:name, :required => true)
+        key.name.should == 'name'
+        key.options[:required].should be_true
+      end
+
+      should "be tracked per document" do
+        @document.key(:name, String)
+        @document.key(:age, Integer)
+        @document.keys['name'].name.should == 'name'
+        @document.keys['name'].type.should == String
+        @document.keys['age'].name.should == 'age'
+        @document.keys['age'].type.should == Integer
+      end
+
+      should "be redefinable" do
+        @document.key(:foo, String)
+        @document.keys['foo'].type.should == String
+        @document.key(:foo, Integer)
+        @document.keys['foo'].type.should == Integer
+      end
+
+      should "create reader method" do
+        @document.new.should_not respond_to(:foo)
+        @document.key(:foo, String)
+        @document.new.should respond_to(:foo)
+      end
+
+      should "create reader before typecast method" do
+        @document.new.should_not respond_to(:foo_before_typecast)
+        @document.key(:foo, String)
+        @document.new.should respond_to(:foo_before_typecast)
+      end
+
+      should "create writer method" do
+        @document.new.should_not respond_to(:foo=)
+        @document.key(:foo, String)
+        @document.new.should respond_to(:foo=)
+      end
+
+      should "create boolean method" do
+        @document.new.should_not respond_to(:foo?)
+        @document.key(:foo, String)
+        @document.new.should respond_to(:foo?)
+      end
+    end
+    
+    context "keys" do
+      should "be inherited" do
+        Grandparent.keys.keys.sort.should == ['_id', 'grandparent']
+        Parent.keys.keys.sort.should == ['_id', 'grandparent', 'parent']
+        Child.keys.keys.sort.should  == ['_id', 'child', 'grandparent', 'parent']
+      end
+
+      should "propogate to descendants if key added after class definition" do
+        Grandparent.key :_type, String
+
+        Grandparent.keys.keys.sort.should == ['_id', '_type', 'grandparent']
+        Parent.keys.keys.sort.should      == ['_id', '_type', 'grandparent', 'parent']
+        Child.keys.keys.sort.should       == ['_id', '_type', 'child', 'grandparent', 'parent']
+      end
+
+      should "not add anonymous objects to the ancestor tree" do
+        OtherChild.ancestors.any? { |a| a.name.blank? }.should be_false
+      end
+
+      should "not include descendant keys" do
+        lambda { Parent.new.other_child }.should raise_error
+      end
+    end
+    
+    context "descendants" do
+      should "default to nil" do
+        Child.descendants.should be_nil
+      end
+
+      should "be recorded" do
+        Grandparent.descendants.should == [Parent]
+        Parent.descendants.should      == [Child, OtherChild]
+      end
+    end
+  end
+
+  context "An instance of an embedded document" do
+    setup do
+      @document = EDoc do
+        key :name, String
+        key :age, Integer
+      end
+    end
+    
+    should "have to_param that is string representation of id" do
+      doc = @document.new
+      doc.to_param.should == doc.id.to_s
+      doc.to_param.should be_instance_of(String)
+    end
+    
+    should "have access to class logger" do
+      doc = @document.new
+      doc.logger.should == @document.logger
+      doc.logger.should be_instance_of(Logger)
+    end
+    
+    should "automatically have an _id key" do
+      @document.keys.keys.should include('_id')
+    end
+    
+    should "create id during initialization" do
+      @document.new._id.should be_instance_of(Mongo::ObjectID)
+    end
+    
+    should "have id method returns _id" do
+      id = Mongo::ObjectID.new
+      doc = @document.new(:_id => id)
+      doc.id.should == id
+    end
+    
+    should "convert string object id to mongo object id when assigning id with _id object id type" do
+      id = Mongo::ObjectID.new
+      
+      doc = @document.new(:id => id.to_s)
+      doc._id.should == id
+      doc.id.should == id
+      
+      doc = @document.new(:_id => id.to_s)
+      doc._id.should == id
+      doc.id.should == id
+    end
+
+    context "_root_document" do
+      should "default to nil" do
+        @document.new._root_document.should be_nil
+      end
+
+      should "allow setting when initialized" do
+        root = Doc().new
+        doc  = @document.new :_root_document => root
+        
+        doc._root_document.should be(root)
+      end
+
+      should "also be set on many embedded documents" do
+        root  = Doc().new
+        klass = EDoc { many :children }
+        doc   = klass.new(:_root_document => root, :children => [{}])
+        
+        doc.children.first._root_document.should == root
+      end
+    end
+
+    context "being initialized" do
+      should "accept a hash that sets keys and values" do
+        doc = @document.new(:name => 'John', :age => 23)
+        doc.attributes.keys.sort.should == ['_id', 'age', 'name']
+        doc.attributes['name'].should == 'John'
+        doc.attributes['age'].should == 23
+      end
+      
+      should "be able to assign keys dynamically" do
+        doc = @document.new(:name => 'John', :skills => ['ruby', 'rails'])
+        doc.name.should == 'John'
+        doc.skills.should == ['ruby', 'rails']
+      end
+
+      should "not throw error if initialized with nil" do
+        assert_nothing_raised { @document.new(nil) }
+      end
+    end
+    
+    context "initialized when _type key present" do
+      setup do
+        @klass = EDoc('FooBar') { key :_type, String }
+      end
+
+      should "set _type to class name" do
+        @klass.new._type.should == 'FooBar'
+      end
+      
+      should "not change _type if already set" do
+        @klass.new(:_type => 'Foo')._type.should == 'Foo'
+      end
+    end
+
+    context "attributes=" do
+      should "update values for keys provided" do
+        doc = @document.new(:name => 'foobar', :age => 10)
+        doc.attributes = {:name => 'new value', :age => 5}
+        doc.attributes[:name].should == 'new value'
+        doc.attributes[:age].should == 5
+      end
+
+      should "not update values for keys that were not provided" do
+        doc = @document.new(:name => 'foobar', :age => 10)
+        doc.attributes = {:name => 'new value'}
+        doc.attributes[:name].should == 'new value'
+        doc.attributes[:age].should == 10
+      end
+
+      should "work with pre-defined methods" do
+        @document.class_eval do
+          attr_writer :password
+
+          def passwd
+            @password
+          end
+        end
+
+        doc = @document.new(:name => 'foobar', :password => 'secret')
+        doc.passwd.should == 'secret'
+      end
+
+      should "typecast key values" do
+        doc = @document.new(:name => 1234, :age => '21')
+        doc.name.should == '1234'
+        doc.age.should == 21
+      end
+    end
+
+    context "attributes" do
+      should "default to hash with all keys" do
+        doc = @document.new
+        doc.attributes.keys.sort.should == ['_id', 'age', 'name']
+      end
+
+      should "return all keys with values" do
+        doc = @document.new(:name => 'string', :age => nil)
+        doc.attributes.keys.sort.should == ['_id', 'age', 'name']
+        doc.attributes.values.should include('string')
+        doc.attributes.values.should include(nil)
+      end
+      
+      should "have indifferent access" do
+        doc = @document.new(:name => 'string')
+        doc.attributes[:name].should == 'string'
+        doc.attributes['name'].should == 'string'
+      end
+    end
+    
+    context "to_mongo" do
+      should "default to hash with _id key" do
+        doc = @document.new
+        doc.to_mongo.keys.sort.should == ['_id', 'age', 'name']
+      end
+      
+      should "return all keys" do
+        doc = @document.new(:name => 'string', :age => nil)
+        doc.to_mongo.keys.sort.should == ['_id', 'age', 'name']
+        doc.to_mongo.values.should include('string')
+        doc.to_mongo.values.should include(nil)
+      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
+    
+    context "key shorcut access" do
+      context "[]" do
+        should "work when key found" do
+          doc = @document.new(:name => 'string')
+          doc[:name].should == 'string'
+        end
+        
+        should "raise exception when key not found" do
+          doc = @document.new(:name => 'string')
+          assert_raises(MongoMapper::KeyNotFound) { doc[:not_here] }
+        end
+      end
+      
+      context "[]=" do
+        should "write key value for existing key" do
+          doc = @document.new
+          doc[:name] = 'string'
+          doc[:name].should == 'string'
+        end
+        
+        should "create key and write value for missing key" do
+          doc = @document.new
+          doc[:foo] = 'string'
+          doc.class.keys.include?('foo').should be_true
+          doc[:foo].should == 'string'
+        end
+
+         should "share the new key with the class" do
+           doc = @document.new
+           doc[:foo] = 'string'
+           @document.keys.should include('foo')
+         end
+      end
+    end
+
+    context "reading a key" do
+      should "work for defined keys" do
+        doc = @document.new(:name => 'string')
+        doc.name.should == 'string'
+      end
+
+      should "raise no method error for undefined keys" do
+        doc = @document.new
+        lambda { doc.fart }.should raise_error(NoMethodError)
+      end
+
+      should "be accessible for use in the model" do
+        @document.class_eval do
+          def name_and_age
+            "#{self[:name]} (#{self[:age]})"
+          end
+        end
+
+        doc = @document.new(:name => 'John', :age => 27)
+        doc.name_and_age.should == 'John (27)'
+      end
+      
+      should "set instance variable" do
+        @document.key :foo, Array
+        doc = @document.new
+        doc.instance_variable_get("@foo").should be_nil
+        doc.foo
+        doc.instance_variable_get("@foo").should == []
+      end
+      
+      should "be overrideable by modules" do
+        @document = Doc do
+          key :other_child, String
+        end
+        
+        child = @document.new
+        child.other_child.should be_nil
+        
+        @document.send :include, KeyOverride
+        
+        overriden_child = @document.new
+        overriden_child.other_child.should == 'special result'
+      end
+    end
+
+    context "reading a key before typcasting" do
+      should "work for defined keys" do
+        doc = @document.new(:name => 12)
+        doc.name_before_typecast.should == 12
+      end
+
+      should "raise no method error for undefined keys" do
+        doc = @document.new
+        lambda { doc.foo_before_typecast }.should raise_error(NoMethodError)
+      end
+
+      should "be accessible for use in a document" do
+        @document.class_eval do
+          def untypcasted_name
+            read_key_before_typecast(:name)
+          end
+        end
+
+        doc = @document.new(:name => 12)
+        doc.name.should == '12'
+        doc.untypcasted_name.should == 12
+      end
+    end
+
+    context "writing a key" do
+      should "work for defined keys" do
+        doc = @document.new
+        doc.name = 'John'
+        doc.name.should == 'John'
+      end
+
+      should "raise no method error for undefined keys" do
+        doc = @document.new
+        lambda { doc.fart = 'poof!' }.should raise_error(NoMethodError)
+      end
+
+      should "typecast value" do
+        doc = @document.new
+        doc.name = 1234
+        doc.name.should == '1234'
+        doc.age = '21'
+        doc.age.should == 21
+      end
+      
+      should "be accessible for use in the model" do
+        @document.class_eval do
+          def name_and_age=(new_value)
+            new_value.match(/([^\(\s]+) \((.*)\)/)
+            write_key :name, $1
+            write_key :age, $2
+          end
+        end
+
+        doc = @document.new
+        doc.name_and_age = 'Frank (62)'
+        doc.name.should == 'Frank'
+        doc.age.should == 62
+      end
+      
+      should "be overrideable by modules" do
+        @document = Doc do
+          key :other_child, String
+        end
+        
+        child = @document.new(:other_child => 'foo')
+        child.other_child.should == 'foo'
+        
+        @document.send :include, KeyOverride
+        
+        overriden_child = @document.new(:other_child => 'foo')
+        overriden_child.other_child.should == 'foo modified'
+      end
+    end # writing a key
+    
+    context "checking if a keys value is present" do
+      should "work for defined keys" do
+        doc = @document.new
+        doc.name?.should be_false
+        doc.name = 'John'
+        doc.name?.should be_true
+      end
+      
+      should "raise no method error for undefined keys" do
+        doc = @document.new
+        lambda { doc.fart? }.should raise_error(NoMethodError)
+      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
+    
+    context "reading keys with default values" do
+      setup do
+        @document = EDoc do
+          key :name,      String,   :default => 'foo'
+          key :age,       Integer,  :default => 20
+          key :net_worth, Float,    :default => 100.00
+          key :active,    Boolean,  :default => true
+          key :smart,     Boolean,  :default => false
+          key :skills,    Array,    :default => [1]
+          key :options,   Hash,     :default => {'foo' => 'bar'}
+        end
+
+        @doc = @document.new
+      end
+
+      should "work for strings" do
+        @doc.name.should == 'foo'
+      end
+
+      should "work for integers" do
+        @doc.age.should == 20
+      end
+
+      should "work for floats" do
+        @doc.net_worth.should == 100.00
+      end
+
+      should "work for booleans" do
+        @doc.active.should == true
+        @doc.smart.should == false
+      end
+
+      should "work for arrays" do
+        @doc.skills.should == [1]
+        @doc.skills << 2
+        @doc.skills.should == [1, 2]
+      end
+
+      should "work for hashes" do
+        @doc.options['foo'].should == 'bar'
+        @doc.options['baz'] = 'wick'
+        @doc.options['baz'].should == 'wick'
+      end
+    end
+  end # instance of a embedded document
+end