humanoid 1.2.7

data/spec/unit/mongoid/callbacks_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Humanoid::Callbacks do
+
+  describe ".included" do
+
+    before do
+      @class = Class.new do
+        include Humanoid::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

@@ -0,0 +1,171 @@
+require "spec_helper"
+
+describe Humanoid::Collection do
+
+  let(:master) do
+    stub.quacks_like(Humanoid::Collections::Master.allocate)
+  end
+
+  let(:slaves) do
+    stub.quacks_like(Humanoid::Collections::Slaves.allocate)
+  end
+
+  let(:collection) do
+    Humanoid::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
+
+    Humanoid::Collections::Operations::WRITE.each do |name|
+
+      it "defines #{name}" do
+        collection.should respond_to(name)
+      end
+    end
+
+  end
+
+  context "Mongo::Collection read operations" do
+
+    Humanoid::Collections::Operations::READ.each do |name|
+
+      it "defines #{name}" do
+        collection.should respond_to(name)
+      end
+    end
+  end
+
+  describe "#directed" do
+
+    before do
+      slaves.expects(:empty?).returns(false)
+    end
+
+    context "when an enslave option is not passed" do
+
+      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
+
+      it "overwrites the default" do
+        collection.directed(:enslave => true).should == slaves
+      end
+    end
+
+  end
+
+  describe "#find" do
+
+    before do
+      @cursor = stub.quacks_like(Humanoid::Cursor.allocate)
+      Humanoid::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

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Humanoid::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
+      Humanoid::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
+        Humanoid::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
+        Humanoid::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
+        Humanoid::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

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Humanoid::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
+    Humanoid::Collections::Master.new(db, "people")
+  end
+
+  before do
+    db.expects(:collection).with("people").returns(collection)
+  end
+
+  context "Mongo::Collection operations" do
+
+    Humanoid::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

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Humanoid::Collections::Mimic do
+
+  let(:mimic) do
+    klass = Class.new do
+      include Humanoid::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
+        Humanoid.reconnect_time = 0.10
+      end
+
+      after do
+        Humanoid.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

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe Humanoid::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
+        Humanoid::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
+        Humanoid::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
+        Humanoid::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
+      Humanoid::Collections::Slaves.new([ db ], "people")
+    end
+
+    before do
+      db.expects(:collection).with("people").returns(collection)
+    end
+
+    Humanoid::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