fcoury-mongomapper 0.2.0

data/test/test_embedded_document.rb

@@ -0,0 +1,253 @@
+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 "not throw error if initialized with nil" do
+        doc = @document.new(nil)
+      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 "not ignore keys that have methods defined" 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 "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,148 @@
+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 "#criteria" do
+    should "convert conditions to criteria" do
+      FinderOptions.expects(:to_mongo_criteria).with(:foo => 1).returns({})
+      FinderOptions.new(:conditions => {:foo => 1}).criteria
+    end
+  end
+  
+  context "#options" do
+    should "convert options to mongo options" do
+      FinderOptions.expects(:to_mongo_options).with(:order => 'foo asc', :select => 'foo,bar').returns({})
+      FinderOptions.new(:order => 'foo asc', :select => 'foo,bar').options
+    end
+  end
+  
+  
+  context "Converting conditions to criteria" do
+    should "work with simple criteria" do
+      FinderOptions.to_mongo_criteria(:foo => 'bar').should == {
+        :foo => 'bar'
+      }
+      
+      FinderOptions.to_mongo_criteria(:foo => 'bar', :baz => 'wick').should == {
+        :foo => 'bar', 
+        :baz => 'wick'
+      }
+    end
+    
+    should "use $in for arrays" do
+      FinderOptions.to_mongo_criteria(:foo => [1,2,3]).should == {
+        :foo => {'$in' => [1,2,3]}
+      }
+    end
+    
+    should "work arbitrarily deep" do
+      FinderOptions.to_mongo_criteria(:foo => {:bar => [1,2,3]}).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.to_mongo_options(:order => 'foo asc')[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo ASC')[:sort].should == hash
+    end
+    
+    should "single field with descending direction" do
+      hash = OrderedHash.new
+      hash[:foo] = -1
+      FinderOptions.to_mongo_options(:order => 'foo desc')[:sort].should == hash
+      FinderOptions.to_mongo_options(:order => 'foo DESC')[:sort].should == hash
+    end
+    
+    should "convert field without direction to ascending" do
+      hash = OrderedHash.new
+      hash[:foo] = 1
+      FinderOptions.to_mongo_options(:order => 'foo')[:sort].should == hash
+    end
+    
+    should "convert multiple fields with directions" do
+      hash = OrderedHash.new
+      hash[:foo] = -1
+      hash[:bar] = 1
+      hash[:baz] = -1
+      FinderOptions.to_mongo_options(:order => 'foo desc, bar asc, baz desc')[: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
+      FinderOptions.to_mongo_options(:order => 'foo desc, bar, baz')[:sort].should == hash
+    end
+  end
+  
+  context "offset" do
+    should "default to 0" do
+      FinderOptions.to_mongo_options({})[:offset].should == 0
+    end
+    
+    should "use offset provided" do
+      FinderOptions.to_mongo_options(:offset => 2)[:offset].should == 2
+    end
+    
+    should "covert string to integer" do
+      FinderOptions.to_mongo_options(:offset => '2')[:offset].should == 2
+    end
+  end
+  
+  context "limit" do
+    should "default to 0" do
+      FinderOptions.to_mongo_options({})[:limit].should == 0
+    end
+    
+    should "use offset provided" do
+      FinderOptions.to_mongo_options(:limit => 2)[:limit].should == 2
+    end
+    
+    should "covert string to integer" do
+      FinderOptions.to_mongo_options(:limit => '2')[:limit].should == 2
+    end
+  end
+  
+  context "fields" do
+    should "default to nil" do
+      FinderOptions.to_mongo_options({})[:fields].should be(nil)
+    end
+    
+    should "be converted to nil if empty string" do
+      FinderOptions.to_mongo_options(:fields => '')[:fields].should be(nil)
+    end
+    
+    should "be converted to nil if []" do
+      FinderOptions.to_mongo_options(:fields => [])[:fields].should be(nil)
+    end
+    
+    should "should work with array" do
+      FinderOptions.to_mongo_options({:fields => %w(a b)})[:fields].should == %w(a b)
+    end
+    
+    should "convert comma separated list to array" do
+      FinderOptions.to_mongo_options({:fields => 'a, b'})[: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,62 @@
+require 'pathname'
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+gem 'mocha', '~> 0.9.4'
+gem 'jnunemaker-matchy', '0.4.0'
+
+require 'matchy'
+require 'mocha'
+
+$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