jnunemaker-mongomapper 0.1.0

data/test/test_embedded_document.rb

@@ -0,0 +1,241 @@
+require 'test_helper'
+
+class EmbeddedDocumentTest < Test::Unit::TestCase
+  context "Including MongoMapper::EmbeddedDocument" do
+    setup do
+      @klass = Class.new do
+        include MongoMapper::EmbeddedDocument
+      end
+    end
+        
+    should "clear out document default keys" do
+      @klass.keys.size.should == 0
+    end
+  end
+  
+  context "An instance of an embedded document" do
+    setup do
+      @document = Class.new do
+        include MongoMapper::EmbeddedDocument
+        
+        key :name, String
+        key :age, Integer
+      end
+    end
+    
+    context "when initialized" do
+      should "accept a hash that sets keys and values" do
+        doc = @document.new(:name => 'John', :age => 23)
+        doc.attributes.should == {'name' => 'John', 'age' => 23}
+      end
+      
+      should "silently reject keys that have not been defined" do
+        doc = @document.new(:foobar => 'baz')
+        doc.attributes.should == {}
+      end
+    end
+    
+    context "mass assigning keys" 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 "ignore keys that do not exist" do
+        doc = @document.new(:name => 'foobar', :age => 10)
+        doc.attributes = {:name => 'new value', :foobar => 'baz'}
+        doc.attributes[:name].should == 'new value'
+        doc.attributes[:foobar].should be(nil)
+      end
+
+      should "typecast key values" do
+        doc = @document.new(:name => 1234, :age => '21')
+        doc.name.should == '1234'
+        doc.age.should == 21
+      end
+    end
+
+    context "requesting keys" do
+      should "default to empty hash" do
+        doc = @document.new
+        doc.attributes.should == {}
+      end
+
+      should "return all keys that aren't nil" do
+        doc = @document.new(:name => 'string', :age => nil)
+        doc.attributes.should == {'name' => 'string'}
+      end
+    end
+
+    context "key shorcuts" do
+      should "be able to read key with []" do
+        doc = @document.new(:name => 'string')
+        doc[:name].should == 'string'
+      end
+
+      should "be able to write key value with []=" do
+        doc = @document.new
+        doc[:name] = 'string'
+        doc[:name].should == 'string'
+      end
+    end
+
+    context "indifferent access" do
+      should "be enabled for keys" do
+        doc = @document.new(:name => 'string')
+        doc.attributes[:name].should == 'string'
+        doc.attributes['name'].should == 'string'
+      end
+    end
+
+    context "reading an attribute" 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 "know if reader defined" do
+        doc = @document.new
+        doc.reader?('name').should be(true)
+        doc.reader?(:name).should be(true)
+        doc.reader?('age').should be(true)
+        doc.reader?(:age).should be(true)
+        doc.reader?('foobar').should be(false)
+        doc.reader?(:foobar).should be(false)
+      end
+      
+      should "be accessible for use in the model" do
+        @document.class_eval do
+          def name_and_age
+            "#{read_attribute(:name)} (#{read_attribute(:age)})"
+          end
+        end
+                
+        doc = @document.new(:name => 'John', :age => 27)
+        doc.name_and_age.should == 'John (27)'
+      end
+    end
+    
+    context "reading an attribute 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_attribute_before_typecast(:name)
+          end
+        end
+                
+        doc = @document.new(:name => 12)
+        doc.name.should == '12'
+        doc.untypcasted_name.should == 12
+      end
+    end
+
+    context "writing an attribute" 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 "know if writer defined" do
+        doc = @document.new
+        doc.writer?('name').should be(true)
+        doc.writer?('name=').should be(true)
+        doc.writer?(:name).should be(true)
+        doc.writer?('age').should be(true)
+        doc.writer?('age=').should be(true)
+        doc.writer?(:age).should be(true)
+        doc.writer?('foobar').should be(false)
+        doc.writer?('foobar=').should be(false)
+        doc.writer?(:foobar).should be(false)
+      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_attribute :name, $1
+            write_attribute :age, $2
+          end
+        end
+                
+        doc = @document.new
+        doc.name_and_age = 'Frank (62)'
+        doc.name.should == 'Frank'
+        doc.age.should == 62
+      end
+    end # writing an attribute
+    
+    context "respond_to?" do
+      setup do
+        @doc = @document.new
+      end
+      
+      should "work for readers" do
+        @doc.respond_to?(:name).should be_true
+        @doc.respond_to?('name').should be_true
+      end
+      
+      should "work for writers" do
+        @doc.respond_to?(:name=).should be_true
+        @doc.respond_to?('name=').should be_true
+      end
+      
+      should "work for readers before typecast" do
+        @doc.respond_to?(:name_before_typecast).should be_true
+        @doc.respond_to?('name_before_typecast').should be_true
+      end
+    end
+    
+    context "equality" do
+      should "be true if all keys and values are equal" do
+        doc1 = @document.new(:name => 'John', :age => 27)
+        doc2 = @document.new(:name => 'John', :age => 27)
+        doc1.should == doc2
+      end
+      
+      should "be false if not all the keys and values are equal" do
+        doc1 = @document.new(:name => 'Steve', :age => 27)
+        doc2 = @document.new(:name => 'John', :age => 27)
+        doc1.should_not == doc2
+      end
+    end
+  end # instance of a embedded document
+end

data/test/test_finder_options.rb

@@ -0,0 +1,133 @@
+require 'test_helper'
+
+class FinderOptionsTest < Test::Unit::TestCase
+  include MongoMapper
+  
+  should "raise error if provided something other than a hash" do
+    lambda { FinderOptions.new }.should raise_error(ArgumentError)
+    lambda { FinderOptions.new(1) }.should raise_error(ArgumentError)
+  end
+  
+  should "have symbolize the keys of the hash provided" do
+    FinderOptions.new('offset' => 1).options.keys.map do |key|
+      key.should be_instance_of(Symbol)
+    end
+  end
+  
+  context "Converting conditions to criteria" do
+    should "work with simple criteria" do
+      FinderOptions.new(:conditions => {:foo => 'bar'}).criteria.should == {
+        :foo => 'bar'
+      }
+      
+      FinderOptions.new(:conditions => {:foo => 'bar', :baz => 'wick'}).criteria.should == {
+        :foo => 'bar', 
+        :baz => 'wick'
+      }
+    end
+    
+    should "use $in for arrays" do
+      FinderOptions.new(:conditions => {:foo => [1,2,3]}).criteria.should == {
+        :foo => {'$in' => [1,2,3]}
+      }
+    end
+    
+    should "work arbitrarily deep" do
+      FinderOptions.new(:conditions => {:foo => {:bar => [1,2,3]}}).criteria.should == {
+        :foo => {:bar => {'$in' => [1,2,3]}}
+      }
+    end
+  end
+  
+  context "ordering" do
+    should "single field with ascending direction" do
+      hash = OrderedHash.new
+      hash[:foo] = 1
+      FinderOptions.new(:order => 'foo asc').options[:sort].should == hash
+      FinderOptions.new(:order => 'foo ASC').options[:sort].should == hash
+    end
+    
+    should "single field with descending direction" do
+      hash = OrderedHash.new
+      hash[:foo] = -1
+      FinderOptions.new(:order => 'foo desc').options[:sort].should == hash
+      FinderOptions.new(:order => 'foo DESC').options[:sort].should == hash
+    end
+    
+    should "convert field without direction to ascending" do
+      hash = OrderedHash.new
+      hash[:foo] = 1
+      FinderOptions.new(:order => 'foo').options[:sort].should == hash
+    end
+    
+    should "convert multiple fields with directions" do
+      hash = OrderedHash.new
+      hash[:foo] = -1
+      hash[:bar] = 1
+      hash[:baz] = -1
+      options = FinderOptions.new(:order => 'foo desc, bar asc, baz desc').options[:sort].should == hash
+    end
+    
+    should "convert multiple fields with some missing directions" do
+      hash = OrderedHash.new
+      hash[:foo] = -1
+      hash[:bar] = 1
+      hash[:baz] = 1
+      options = FinderOptions.new(:order => 'foo desc, bar, baz').options[:sort].should == hash
+    end
+  end
+  
+  context "offset" do
+    should "default to 0" do
+      FinderOptions.new({}).options[:offset].should == 0
+    end
+    
+    should "use offset provided" do
+      FinderOptions.new(:offset => 2).options[:offset].should == 2
+    end
+    
+    should "covert string to integer" do
+      FinderOptions.new(:offset => '2').options[:offset].should == 2
+    end
+  end
+  
+  context "limit" do
+    should "default to 0" do
+      FinderOptions.new({}).options[:limit].should == 0
+    end
+    
+    should "use offset provided" do
+      FinderOptions.new(:limit => 2).options[:limit].should == 2
+    end
+    
+    should "covert string to integer" do
+      FinderOptions.new(:limit => '2').options[:limit].should == 2
+    end
+  end
+  
+  context "fields" do
+    should "default to nil" do
+      FinderOptions.new({}).options[:fields].should be(nil)
+    end
+    
+    should "be converted to nil if empty string" do
+      FinderOptions.new(:fields => '').options[:fields].should be(nil)
+    end
+    
+    should "be converted to nil if []" do
+      FinderOptions.new(:fields => []).options[:fields].should be(nil)
+    end
+    
+    should "should work with array" do
+      FinderOptions.new({:fields => %w(a b)}).options[:fields].should == %w(a b)
+    end
+    
+    should "convert comma separated list to array" do
+      FinderOptions.new({:fields => 'a, b'}).options[:fields].should == %w(a b)
+    end
+    
+    should "also work as select" do
+      FinderOptions.new(:select => %w(a b)).options[:fields].should == %w(a b)
+    end
+  end
+end # FinderOptionsTest

data/test/test_helper.rb

@@ -0,0 +1,64 @@
+require 'pathname'
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+gem 'jnunemaker-matchy', '0.4.0'
+gem 'mocha'
+gem 'thoughtbot-quietbacktrace'
+
+require 'matchy'
+require 'mocha'
+require 'quietbacktrace'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+dir = (Pathname(__FILE__).dirname +  '..' + 'lib').expand_path
+require dir + 'mongomapper'
+
+class Test::Unit::TestCase
+  custom_matcher :be_nil do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be nil but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be nil but it was"
+    receiver.nil?
+  end
+  
+  custom_matcher :be_true do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be true but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be true but it was"
+    receiver.eql?(true)
+  end
+  
+  custom_matcher :be_false do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected #{receiver} to be false but it wasn't"
+    matcher.negative_failure_message = "Expected #{receiver} not to be false but it was"
+    receiver.eql?(false)
+  end
+
+  custom_matcher :be_valid do |receiver, matcher, args|
+    matcher.positive_failure_message = "Expected to be valid but it was invalid #{receiver.errors.inspect}"
+    matcher.negative_failure_message = "Expected to be invalid but it was valid #{receiver.errors.inspect}"
+    receiver.valid?
+  end
+
+  custom_matcher :have_error_on do |receiver, matcher, args|
+    receiver.valid?
+    attribute = args[0]
+    expected_message = args[1]
+    
+    if expected_message.nil?
+      matcher.positive_failure_message = "#{receiver} had no errors on #{attribute}"
+      matcher.negative_failure_message = "#{receiver} had errors on #{attribute} #{receiver.errors.inspect}"
+      !receiver.errors.on(attribute).blank?
+    else
+      actual = receiver.errors.on(attribute)
+      matcher.positive_failure_message = %Q(Expected error on #{attribute} to be "#{expected_message}" but was "#{actual}")
+      matcher.negative_failure_message = %Q(Expected error on #{attribute} not to be "#{expected_message}" but was "#{actual}")
+      actual == expected_message
+    end
+  end
+end
+
+DefaultDatabase = 'test' unless defined?(DefaultDatabase)
+AlternateDatabase = 'test2' unless defined?(AlternateDatabase)
+
+MongoMapper.database = DefaultDatabase

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]
+    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_mongo_mapper.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_rails_compatibility.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class TestRailsCompatibility < Test::Unit::TestCase
+  def setup
+    @document = Class.new do
+      include MongoMapper::Document
+    end
+  end
+  
+  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 "have column names" do
+    @document.key :fname, String
+    @document.column_names.sort.should == ['_id', 'created_at', 'fname', 'updated_at']
+  end
+end