mongo_doc_rails2 0.6.1

data/spec/embedded_save_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Saving embedded documents" do
+  class NestedDocsRoot
+    include MongoDoc::Document
+
+    embed_many :nested_children
+  end
+
+  class NestedChild
+    include MongoDoc::Document
+
+    embed :leaf
+  end
+
+  class LeafDoc
+    include MongoDoc::Document
+
+    attr_accessor :data
+  end
+
+  let(:leaf) do
+    doc = LeafDoc.new
+    doc._id = 'id'
+    doc
+  end
+
+  let(:data) { 'data' }
+
+  context "#save" do
+    let(:root) { NestedDocsRoot.new(:nested_children => [NestedChild.new(:leaf => leaf)]) }
+
+    it "calls the root document's save" do
+      root.should_receive(:save).with(true)
+      leaf.save
+    end
+
+    it "(with bang!) calls the root documents save!" do
+      root.should_receive(:save!)
+      leaf.save!
+    end
+  end
+
+  context "update_attributes" do
+    context "with no embed_many, update_attributes" do
+      let(:root) { NestedChild.new(:leaf => leaf) }
+
+      it "calls the root document's _update with a full attribute path and not safe" do
+        root.should_receive(:_update).with({"leaf._id"=>"id"}, {'leaf.data' => data}, false)
+        leaf.update_attributes(:data => data)
+      end
+
+      it "(with bang!) calls the root document's _update with a full attribute path and safe" do
+        root.should_receive(:_update).with({"leaf._id"=>"id"}, {'leaf.data' => data}, true)
+        leaf.update_attributes!(:data => data)
+      end
+    end
+
+    context "with embed_many, update_attributes" do
+      let(:root) { NestedDocsRoot.new(:nested_children => [NestedChild.new(:leaf => leaf)]) }
+
+      it "calls the root document's _update with a full attribute path and not safe" do
+        root.should_receive(:_update).with({"nested_children.leaf._id"=>"id"}, {'nested_children.$.leaf.data' => data}, false)
+        leaf.update_attributes(:data => data)
+      end
+
+      it "(with bang!) calls the root document's _update with a full attribute path and safe" do
+        root.should_receive(:_update).with({"nested_children.leaf._id"=>"id"}, {'nested_children.$.leaf.data' => data}, true)
+        leaf.update_attributes!(:data => data)
+      end
+    end
+  end
+end

data/spec/ext_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper.rb'
+
+describe "Ruby Object Extensions" do
+  context "Rails3 support" do
+    describe "#singleton_class" do
+      it "is either defined or aliased" do
+        Object.new.should respond_to(:singleton_class)
+      end
+    end
+  end
+
+  context "Conversions" do
+    context "Boolean" do
+      it "converts from a '1' to true" do
+        Boolean.cast_from_string('1').should be_true
+      end
+
+      it "converts from a 'tRuE' to true" do
+        Boolean.cast_from_string('tRuE').should be_true
+      end
+
+      it "converts anything else to false" do
+        Boolean.cast_from_string('0').should be_false
+      end
+    end
+
+    context "Date" do
+      it "returns nil for a blank string" do
+        Date.cast_from_string('').should be_nil
+      end
+
+      it "converts from a string to a Date" do
+        date = Date.today
+        Date.cast_from_string(date.to_s).should == date
+      end
+    end
+
+    context "DateTime" do
+      it "returns nil for a blank string" do
+        DateTime.cast_from_string('').should be_nil
+      end
+
+      it "converts from a string to a DateTime" do
+        datetime = DateTime.now
+        DateTime.cast_from_string(datetime.to_s).should === datetime
+      end
+    end
+
+    context "Numeric" do
+      context "BigDecimal" do
+        it "returns nil for a blank string" do
+          BigDecimal.cast_from_string('').should be_nil
+        end
+
+        it "converts from a string to a BigDecimal" do
+          big_decimal = BigDecimal.new("123")
+          BigDecimal.cast_from_string(big_decimal.to_s).should == big_decimal
+        end
+      end
+
+      context "Integer" do
+        it "returns nil for a blank string" do
+          Integer.cast_from_string('').should be_nil
+        end
+
+        it "converts from a string to a Bignum" do
+          big_number = 1000000000000
+          Integer.cast_from_string(big_number.to_s).should == big_number
+        end
+
+        it "converts from a string to a Fixnum" do
+          fixnum = 1
+          Integer.cast_from_string(fixnum.to_s).should == fixnum
+        end
+      end
+    end
+
+    context "Time" do
+      it "returns nil for a blank string" do
+        Time.cast_from_string('').should be_nil
+      end
+
+      it "converts from a string to a Time" do
+        time = Time.now
+        Time.cast_from_string(time.to_s).to_s.should == time.to_s
+      end
+    end
+  end
+end

data/spec/finders_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper.rb"))
+
+describe MongoDoc::Finders do
+  class FindersTest
+    include MongoDoc::Document
+
+    attr_accessor :data
+  end
+
+  let(:criteria) { stub('criteria').as_null_object }
+
+  context ".find" do
+    before do
+      FindersTest.stub(:criteria).and_return(criteria)
+    end
+
+    it "delegates to id for the criteria" do
+      args = [1, 2, 3]
+      criteria.should_receive(:id).with(*args)
+      FindersTest.find(*args)
+    end
+  end
+
+  context ".find_all" do
+    it "delegates to an empty criteria" do
+      FindersTest.should_receive(:criteria)
+      FindersTest.find_all
+    end
+
+    it "returns the empty criteria" do
+      FindersTest.stub(:criteria).and_return(criteria)
+      FindersTest.find_all.should == criteria
+    end
+  end
+
+  context ".find_one" do
+    context "with an id" do
+      it "delegates to translate" do
+        id = 'an id'
+        Mongoid::Criteria.should_receive(:translate).with(FindersTest, id)
+        FindersTest.find_one(id)
+      end
+    end
+
+    context "with conditions" do
+      let(:conditions) { {:where => 'this.a > 3'} }
+
+      it "calls translate with the conditions" do
+        Mongoid::Criteria.should_receive(:translate).with(FindersTest, conditions).and_return(criteria)
+        FindersTest.find_one(conditions)
+      end
+
+      it "call one on the result" do
+        Mongoid::Criteria.stub(:translate).and_return(criteria)
+        criteria.should_receive(:one)
+        FindersTest.find_one(conditions)
+      end
+    end
+  end
+
+end

data/spec/hash_matchers.rb

@@ -0,0 +1,27 @@
+class HasEntry
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(target)
+    @target = target
+    @expected.all? do |key, value|
+      @target[key] == value
+    end
+  end
+
+  def failure_message_for_should
+    "expected #{@target.inspect} to have entries #{@expected.inspect}"
+  end
+
+  def failure_message_for_should_not
+    "expected #{@target.inspect} not to have entries #{@expected.inspect}"
+  end
+end
+
+module HashMatchers
+  def has_entry(expected)
+    HasEntry.new(expected)
+  end
+  alias :has_entries :has_entry
+end

data/spec/index_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper.rb"
+
+describe MongoDoc::Index do
+  class Address
+    include MongoDoc::Document
+
+    attr_accessor :state
+  end
+
+  class IndexTest
+    include MongoDoc::Document
+
+    attr_accessor :ssn
+    attr_accessor :first_name
+    attr_accessor :last_name
+    attr_accessor :birthdate, :type => Date
+    attr_accessor :notes
+    attr_accessor :location, :type => Array
+
+    embed :addresses
+
+    # This is the API we are testing, commented out to avoid firing before
+    # specs are run
+    #
+    # index :birthdate
+    # index :ssn, :unique => true
+    # index :first_name => :asc, :last_name => :asc
+    # index :last_name => :asc, :first_name => :asc, :unique => true
+    # index "addresses.state"
+    # index :location => :geo2d
+  end
+
+  let(:collection) { stub('collection') }
+
+  before do
+    IndexTest.stub(:collection).and_return(collection)
+  end
+
+  context "Simple index" do
+
+    it "creates an index for the field" do
+      collection.should_receive(:create_index).with(:birthdate, {})
+      IndexTest.index(:birthdate)
+    end
+
+    it "creates a unique index for the field" do
+      collection.should_receive(:create_index).with(:birthdate, {:unique => true})
+      IndexTest.index(:birthdate, :unique => true)
+    end
+
+  end
+
+  context "Compound index" do
+
+    it "creates a compound index" do
+      collection.should_receive(:create_index).with(array_including([:first_name, Mongo::ASCENDING], [:last_name, Mongo::ASCENDING]), {})
+      IndexTest.index(:first_name => :asc, :last_name => :asc)
+    end
+
+    it "creates a unique compound index" do
+      collection.should_receive(:create_index).with(array_including([:first_name, Mongo::ASCENDING], [:last_name, Mongo::ASCENDING]), {:unique => true})
+      IndexTest.index(:first_name => :asc, :last_name => :asc, :unique => true)
+    end
+  end
+
+  context "Nested index" do
+    it "creates an index for the field" do
+      collection.should_receive(:create_index).with("addresses.state", {})
+      IndexTest.index("addresses.state")
+    end
+  end
+
+  context "Geo index" do
+    it "creates a geo index for the field" do
+      collection.should_receive(:create_index).with([[:location, Mongo::GEO2D]], {})
+      IndexTest.index(:location => :geo2d)
+    end
+  end
+end

data/spec/matchers_spec.rb

@@ -0,0 +1,342 @@
+require "spec_helper"
+
+describe MongoDoc::Matchers do
+
+  class Address
+    include MongoDoc::Matchers
+
+    attr_accessor :number
+    attr_accessor :services
+    attr_accessor :street
+
+    def initialize(attrs = {})
+      attrs.each {|key, value| send("#{key}=", value)}
+    end
+  end
+
+  describe "#matches?" do
+
+    context "when performing simple matching" do
+
+      before do
+        @document = Address.new(:street => "Clarkenwell Road")
+      end
+
+      context "when the attributes match" do
+
+        before do
+          @selector = { :street => "Clarkenwell Road" }
+        end
+
+        it "returns true" do
+          @document.matches?(@selector).should be_true
+        end
+
+      end
+
+      context "when the attributes dont match" do
+
+        before do
+          @selector = { :street => "Broadway Ave" }
+        end
+
+        it "returns false" do
+          @document.matches?(@selector).should be_false
+        end
+
+      end
+
+    end
+
+    context "when performing complex matching" do
+
+      before do
+        @document = Address.new(:services => ["first", "second"], :number => 100)
+      end
+
+      context "with an $all selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :services => { "$all" => [ "first", "second" ] } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :services => { "$all" => [ "first" ] } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with an $exists selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :services => { "$exists" => true } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :services => { "$exists" => false } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $gt selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$gt" => 50 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$gt" => 200 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $gte selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$gte" => 100 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$gte" => 200 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with an $in selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$in" => [ 100, 200 ] } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$in" => [ 200, 300 ] } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $lt selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$lt" => 200 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$lt" => 50 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $lte selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$lte" => 200 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$lte" => 50 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with an $ne selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$ne" => 200 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$ne" => 100 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $nin selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :number => { "$nin" => [ 1, 2, 3 ] } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :number => { "$nin" => [ 100 ] } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+      context "with a $size selector" do
+
+        context "when the attributes match" do
+
+          before do
+            @selector = { :services => { "$size" => 2 } }
+          end
+
+          it "returns true" do
+            @document.matches?(@selector).should be_true
+          end
+
+        end
+
+        context "when the attributes do not match" do
+
+          before do
+            @selector = { :services => { "$size" => 5 } }
+          end
+
+          it "returns false" do
+            @document.matches?(@selector).should be_false
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end
+