mongoid 1.2.14 → 1.9.0

data/spec/unit/mongoid/callbacks_spec.rb

@@ -1,55 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Callbacks do
-
-  describe ".included" do
-
-    before do
-      @class = Class.new do
-        include Mongoid::Callbacks
-      end
-    end
-
-    it "includes the before_create callback" do
-      @class.should respond_to(:before_create)
-    end
-
-    it "includes the after_create callback" do
-      @class.should respond_to(:after_create)
-    end
-
-    it "includes the before_destroy callback" do
-      @class.should respond_to(:before_destroy)
-    end
-
-    it "includes the after_destroy callback" do
-      @class.should respond_to(:after_destroy)
-    end
-
-    it "includes the before_save callback" do
-      @class.should respond_to(:before_save)
-    end
-
-    it "includes the after_save callback" do
-      @class.should respond_to(:after_save)
-    end
-
-    it "includes the before_update callback" do
-      @class.should respond_to(:before_update)
-    end
-
-    it "includes the after_update callback" do
-      @class.should respond_to(:after_update)
-    end
-
-    it "includes the before_validation callback" do
-      @class.should respond_to(:before_validation)
-    end
-
-    it "includes the after_validation callback" do
-      @class.should respond_to(:after_validation)
-    end
-
-  end
-
-end

data/spec/unit/mongoid/collection_spec.rb

@@ -1,187 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Collection do
-
-  let(:master) do
-    stub.quacks_like(Mongoid::Collections::Master.allocate)
-  end
-
-  let(:slaves) do
-    stub.quacks_like(Mongoid::Collections::Slaves.allocate)
-  end
-
-  let(:collection) do
-    Mongoid::Collection.new(Person, "people")
-  end
-
-  before do
-    collection.instance_variable_set(:@master, master)
-    collection.instance_variable_set(:@slaves, slaves)
-  end
-
-  context "Mongo::Collection write operations" do
-
-    Mongoid::Collections::Operations::WRITE.each do |name|
-
-      it "defines #{name}" do
-        collection.should respond_to(name)
-      end
-    end
-
-  end
-
-  context "Mongo::Collection read operations" do
-
-    Mongoid::Collections::Operations::READ.each do |name|
-
-      it "defines #{name}" do
-        collection.should respond_to(name)
-      end
-    end
-  end
-
-  describe "#directed" do
-
-    context "when an enslave option is not passed" do
-
-      before do
-        slaves.expects(:empty?).returns(false)
-      end
-
-      before do
-        Person.enslave
-      end
-
-      after do
-        Person.enslaved = false
-      end
-
-      it "uses the default" do
-        collection.directed.should == slaves
-      end
-    end
-
-    context "when an enslave option is passed" do
-
-      before do
-        slaves.expects(:empty?).returns(false)
-      end
-
-      it "overwrites the default" do
-        collection.directed(:enslave => true).should == slaves
-      end
-    end
-
-    context "when cached option is passed" do
-
-      let(:options) do
-        { :cache => true }
-      end
-
-      it "removed the cache option" do
-        collection.directed(options).should == master
-        options[:cache].should be_nil
-      end
-    end
-
-  end
-
-  describe "#find" do
-
-    before do
-      @cursor = stub.quacks_like(Mongoid::Cursor.allocate)
-      Mongoid::Cursor.expects(:new).with(Person, collection, @mongo_cursor).returns(@cursor)
-    end
-
-    context "when no block supplied" do
-
-      before do
-        master.expects(:find).with({ :test => "value" }, {}).returns(@mongo_cursor)
-      end
-
-      it "finds return a cursor" do
-        collection.find({ :test => "value"}).should == @cursor
-      end
-
-    end
-
-    context "when a block is supplied" do
-
-      before do
-        master.expects(:find).with({ :test => "value" }, {}).returns(@mongo_cursor)
-      end
-
-      it "yields to the cursor and closes it" do
-        @cursor.expects(:close).returns(true)
-        collection.find({ :test => "value" }) do |cur|
-          cur.should == @cursor
-        end
-      end
-    end
-
-    context "when an enslave option exists" do
-
-      before do
-        @options = { :enslave => true }
-        slaves.expects(:empty?).returns(false)
-        slaves.expects(:find).with({ :test => "value" }, {}).returns(@mongo_cursor)
-      end
-
-      it "sends the query to the slave pool" do
-        collection.find({ :test => "value"}, @options).should == @cursor
-      end
-
-      it "deletes the enslave option" do
-        collection.find({ :test => "value"}, @options)
-        @options[:enslave].should be_nil
-      end
-    end
-
-    context "when an enslave option does not exist" do
-
-      before do
-        master.expects(:find).with({ :test => "value" }, {}).returns(@mongo_cursor)
-      end
-
-      it "sends the query to the master" do
-        collection.find({ :test => "value"}).should == @cursor
-      end
-    end
-  end
-
-  describe "#find_one" do
-
-    before do
-      @person = stub
-    end
-
-    context "when an enslave option exists" do
-
-      before do
-        @options = { :enslave => true }
-        slaves.expects(:empty?).returns(false)
-        slaves.expects(:find_one).with({ :test => "value" }, {}).returns(@person)
-      end
-
-      it "sends the query to the slave pool" do
-        collection.find_one({ :test => "value"}, @options).should == @person
-      end
-
-      it "deletes the enslave option" do
-        collection.find_one({ :test => "value"}, @options)
-        @options[:enslave].should be_nil
-      end
-    end
-
-    context "when an enslave option does not exist" do
-
-      before do
-        master.expects(:find_one).with({ :test => "value" }, {}).returns(@person)
-      end
-
-      it "sends the query to the master" do
-        collection.find_one({ :test => "value"}).should == @person
-      end
-    end
-  end
-end

data/spec/unit/mongoid/collections/cyclic_iterator_spec.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Collections::CyclicIterator do
-
-  before do
-    @first = stub
-    @second = stub
-    @third = stub
-    @fourth = stub
-  end
-
-  let(:array) do
-    [ @first, @second, @third, @fourth ]
-  end
-
-  describe "#initialize" do
-
-    let(:iterator) do
-      Mongoid::Collections::CyclicIterator.new(array)
-    end
-
-    it "defaults the counter to -1" do
-      iterator.counter.should == -1
-    end
-  end
-
-  describe "#next" do
-
-    context "when the iterator has just been created" do
-
-      let(:iterator) do
-        Mongoid::Collections::CyclicIterator.new(array)
-      end
-
-      it "returns the first element" do
-        iterator.next.should == @first
-      end
-    end
-
-    context "when the iterator is in the middle" do
-
-      let(:iterator) do
-        Mongoid::Collections::CyclicIterator.new(array)
-      end
-
-      before do
-        2.times { iterator.next }
-      end
-
-      it "returns the next element given the index" do
-        iterator.next.should == @third
-      end
-    end
-
-    context "when the iterator is on the last element" do
-
-      let(:iterator) do
-        Mongoid::Collections::CyclicIterator.new(array)
-      end
-
-      before do
-        4.times { iterator.next }
-      end
-
-      it "returns the first element" do
-        iterator.next.should == @first
-      end
-
-      it "resets the counter" do
-        iterator.next
-        iterator.counter.should == 0
-      end
-    end
-  end
-end

data/spec/unit/mongoid/collections/master_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Collections::Master do
-
-  let(:collection) do
-    stub.quacks_like(Mongo::Collection.allocate)
-  end
-
-  let(:db) do
-    stub.quacks_like(Mongo::DB.allocate)
-  end
-
-  let(:master) do
-    Mongoid::Collections::Master.new(db, "people")
-  end
-
-  before do
-    db.expects(:collection).with("people").returns(collection)
-  end
-
-  context "Mongo::Collection operations" do
-
-    Mongoid::Collections::Operations::ALL.each do |name|
-
-      it "defines #{name}" do
-        master.should respond_to(name)
-      end
-
-      describe "##{name}" do
-
-        before do
-          collection.expects(name)
-        end
-
-        it "delegates to the collection" do
-          master.send(name)
-        end
-      end
-    end
-  end
-end

data/spec/unit/mongoid/collections/mimic_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Collections::Mimic do
-
-  let(:mimic) do
-    klass = Class.new do
-      include Mongoid::Collections::Mimic
-    end
-    klass.new
-  end
-
-  describe "#attempt" do
-
-    before do
-      @operation = stub.quacks_like(Proc.new {})
-    end
-
-    context "when the call succeeds" do
-
-      it "returns the value" do
-        @operation.expects(:call).returns([])
-        mimic.attempt(@operation, Time.now).should == []
-      end
-    end
-
-    context "when the call fails" do
-
-      before do
-        Mongoid.reconnect_time = 0.10
-      end
-
-      after do
-        Mongoid.reconnect_time = 3
-      end
-
-      it "retries the call" do
-        @operation.expects(:call).at_least_once.raises(Mongo::ConnectionFailure.new)
-        lambda { mimic.attempt(@operation, Time.now) }.should raise_error
-      end
-    end
-
-  end
-end

data/spec/unit/mongoid/collections/slaves_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-
-describe Mongoid::Collections::Master do
-
-  let(:collection) do
-    stub.quacks_like(Mongo::Collection.allocate)
-  end
-
-  let(:db) do
-    stub.quacks_like(Mongo::DB.allocate)
-  end
-
-  describe "#empty?" do
-
-    context "when the slaves exist" do
-
-      let(:slave) do
-        Mongoid::Collections::Slaves.new([ db ], "people")
-      end
-
-      before do
-        db.expects(:collection).with("people").returns(collection)
-      end
-
-      it "returns false" do
-        slave.should_not be_empty
-      end
-    end
-
-    context "when the slaves do not exist" do
-
-      let(:slave) do
-        Mongoid::Collections::Slaves.new([], "people")
-      end
-
-      it "returns true" do
-        slave.should be_empty
-      end
-    end
-
-    context "when the slaves are nil" do
-
-      let(:slave) do
-        Mongoid::Collections::Slaves.new(nil, "people")
-      end
-
-      it "returns true" do
-        slave.should be_empty
-      end
-    end
-  end
-
-  context "Mongo::Collection operations" do
-
-    let(:slave) do
-      Mongoid::Collections::Slaves.new([ db ], "people")
-    end
-
-    before do
-      db.expects(:collection).with("people").returns(collection)
-    end
-
-    Mongoid::Collections::Operations::READ.each do |name|
-
-      it "defines #{name}" do
-        slave.should respond_to(name)
-      end
-
-      describe "##{name}" do
-
-        before do
-          collection.expects(name)
-        end
-
-        it "delegates to the collection" do
-          slave.send(name)
-        end
-      end
-    end
-  end
-end