mongo_doc 0.6.26 → 0.6.27

data/spec/ext_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper'
-
-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 "Numbers" do
-      context "Float" do
-        it "returns nil for a blank string" do
-          Float.cast_from_string('').should be_nil
-        end
-
-        it "converts from a string to a BigDecimal" do
-          float = "12345.6789".to_f
-          Float.cast_from_string(float.to_s).should == float
-        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 "ObjectID" do
-      it "returns nil for a blank string" do
-        BSON::ObjectID.cast_from_string('').should be_nil
-      end
-
-      it "converts from a string to an ObjectID" do
-        obj = BSON::ObjectID.new
-        BSON::ObjectID.cast_from_string(obj.to_s).should == obj
-      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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-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

@@ -1,29 +0,0 @@
-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
-  alias :have_entries :has_entry
-  alias :have_entry :has_entry
-end

data/spec/index_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-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

@@ -1,342 +0,0 @@
-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
-

data/spec/mongodb.yml

@@ -1,6 +0,0 @@
-name: database_name
-host: localhost
-port: 27017
-options:
-  auto_reconnect: true
-

data/spec/mongodb_pairs.yml

@@ -1,8 +0,0 @@
-name: database_name
-host_pairs:
-  first:
-    ['localhost', 27017]
-port: 27017
-options:
-  auto_reconnect: true
-