humanoid 1.2.7

data/spec/unit/mongoid/memoization_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe Humanoid::Memoization do
+
+  let(:memo) { "Memo" }
+
+  before do
+    @person = Person.new
+  end
+
+  describe "#memoized" do
+
+    context "when variable has been defined" do
+
+      before do
+        @person.instance_variable_set("@memo", memo)
+      end
+
+      it "returns the memoized value" do
+        @person.memoized(:memo) { nil }.should == memo
+      end
+
+    end
+
+    context "when variable has not been defined" do
+
+      it "returns the new value" do
+        @person.memoized(:memo) { memo }.should == memo
+      end
+
+      it "memoizes the new value" do
+        @person.memoized(:memo) { memo }
+        @person.instance_variable_get("@memo").should == memo
+      end
+
+    end
+
+  end
+
+  describe "#reset" do
+
+    context "when variable has been defined" do
+
+      before do
+        @person.instance_variable_set("@memo", memo)
+      end
+
+      it "removes the memoized value" do
+        @person.reset(:memo) { nil }
+        @person.instance_variable_defined?("@memo").should be_false
+      end
+
+      it "returns the new value" do
+        @person.reset(:memo) { memo }.should == memo
+      end
+
+    end
+
+    context "when variable has not been defined" do
+
+      it "memoizes the new value" do
+        @person.reset(:memo) { memo }
+        @person.instance_variable_get("@memo").should == memo
+      end
+
+      it "returns the value" do
+        @person.reset(:memo) { memo }.should == memo
+      end
+
+    end
+
+
+  end
+
+end

data/spec/unit/mongoid/named_scope_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+describe Humanoid::NamedScope do
+
+  class Player
+    include Humanoid::Document
+    field :active, :type => Boolean
+    field :frags, :type => Integer
+    field :deaths, :type => Integer
+    field :status
+
+    named_scope :active, criteria.where(:active => true) do
+      def extension
+        "extension"
+      end
+    end
+    named_scope :inactive, :where => { :active => false }
+    named_scope :frags_over, lambda { |count| { :where => { :frags.gt => count } } }
+    named_scope :deaths_under, lambda { |count| criteria.where(:deaths.lt => count) }
+    scope :deaths_over, lambda { |count| criteria.where(:deaths.gt => count) }
+
+    class << self
+      def alive
+        criteria.where(:status => "Alive")
+      end
+    end
+  end
+
+  describe ".named_scope" do
+
+    it "adds a class method for the scope" do
+      Player.should respond_to(:active)
+    end
+
+    it "adds the scope to the scopes" do
+      Player.scopes.should include(:active)
+    end
+
+    context "when options are a hash" do
+
+      it "adds the selector to the scope" do
+        Player.inactive.selector[:active].should be_false
+      end
+
+    end
+
+    context "when options are a criteria" do
+
+      it "adds the selector to the scope" do
+        Player.active.selector[:active].should be_true
+      end
+
+    end
+
+    context "when options are a proc" do
+
+      context "when the proc delegates to a hash" do
+
+        it "adds the selector to the scope" do
+          Player.frags_over(50).selector[:frags].should == { "$gt" => 50 }
+        end
+
+      end
+
+      context "when the proc delegates to a criteria" do
+
+        it "adds the selector to the scope" do
+          Player.deaths_under(40).selector[:deaths].should == { "$lt" => 40 }
+        end
+
+      end
+
+    end
+
+    context "when a block is supplied" do
+
+      it "adds a class method for the scope" do
+        Player.should respond_to(:deaths_over)
+      end
+
+      it "adds the scope to the scopes" do
+        Player.scopes.should include(:deaths_over)
+      end
+
+    end
+
+  end
+
+  describe ".scope" do
+
+    it "aliases to named_scope" do
+      Player.should respond_to(:deaths_over)
+    end
+
+  end
+
+  context "chained scopes" do
+
+    context "when chaining two named scopes" do
+
+      it "merges the criteria" do
+        selector = Player.active.frags_over(10).selector
+        selector[:active].should be_true
+        selector[:frags].should == { "$gt" => 10 }
+      end
+
+    end
+
+    context "when chaining named scoped with criteria class methods" do
+
+      it "merges the criteria" do
+        selector = Player.active.frags_over(10).alive.selector
+        selector[:active].should be_true
+        selector[:frags].should == { "$gt" => 10 }
+        selector[:status].should == "Alive"
+      end
+
+    end
+
+  end
+
+end
+

data/spec/unit/mongoid/scope_spec.rb

@@ -0,0 +1,240 @@
+require "spec_helper"
+
+describe Humanoid::Scope do
+
+  before do
+    Person.delete_all
+  end
+
+  describe "#==" do
+
+    before do
+      @scope = Humanoid::Scope.new(Person, {})
+    end
+
+    context "when other is a scope" do
+
+      context "when the parent and conditions match" do
+
+        before do
+          @other = Humanoid::Scope.new(Person, {})
+        end
+
+        it "returns true" do
+          @scope.should == @other
+        end
+
+      end
+
+      context "when the conditions do not match" do
+
+        before do
+          @other = Humanoid::Scope.new(Person, { :where => { :field => "value" } })
+        end
+
+        it "returns false" do
+          @scope.should_not == @other
+        end
+      end
+
+    end
+
+    context "when other is an enumerable" do
+
+      context "when the array contents are equal" do
+
+        before do
+          @other = []
+        end
+
+        it "returns true" do
+          @scope.should == @other
+        end
+
+      end
+
+      context "when the array contents are not equal" do
+
+        before do
+          @other = [ stub ]
+        end
+
+        it "returns false" do
+          @scope.should_not == @other
+        end
+
+      end
+    end
+
+    context "when other is an invalid type" do
+
+      it "returns false" do
+        Humanoid::Scope.new(Person, {}).should_not == stub
+      end
+
+    end
+
+  end
+
+  describe ".initialize" do
+
+    before do
+      @parent = Humanoid::Scope.new(Person, {})
+    end
+
+    context "when parent is another scope" do
+
+      before do
+        @scope = Humanoid::Scope.new(@parent, {})
+      end
+
+      it "does not set the class" do
+        @scope.klass.should be_nil
+      end
+
+    end
+
+    context "when parent is a class" do
+
+      before do
+        @scope = Humanoid::Scope.new(Person, {})
+      end
+
+      it "returns the parent class" do
+        @scope.klass.should == Person
+      end
+
+    end
+
+    context "when a block is passed in" do
+
+      before do
+        @scope = Humanoid::Scope.new(Person, {}) do
+          def extended
+            "extended"
+          end
+        end
+      end
+
+      it "extends the block" do
+        @scope.extended.should == "extended"
+      end
+
+    end
+
+  end
+
+  describe "#method_missing" do
+
+    context "when a scope has been defined for the name" do
+
+      before do
+        @defined = mock
+        @class = mock
+        @class.expects(:scopes).twice.returns({ :testing => @defined })
+        @scope = Humanoid::Scope.new(@class, {})
+      end
+
+      it "calls the matching scope" do
+        @defined.expects(:call).with(@scope, "Testing").returns(true)
+        @scope.testing("Testing").should be_true
+      end
+
+    end
+
+    context "when a scope is not defined for the name" do
+
+      context "when the scope is the parent" do
+
+        before do
+          @target = mock
+          @scope = Humanoid::Scope.new(Person, {})
+          @scope.instance_variable_set("@target", @target)
+        end
+
+        it "sends the call to the target" do
+          @target.expects(:testing).with("Testing").returns(true)
+          @scope.testing("Testing").should be_true
+        end
+
+      end
+
+      context "when the scope is not the parent" do
+
+        before do
+          @parent = mock
+          @criteria = mock
+          @parent.expects(:scopes).returns({})
+          @parent.expects(:is_a?).with(Humanoid::Scope).returns(true)
+          @parent.expects(:fuse)
+          @scope = Humanoid::Scope.new(@parent, {})
+        end
+
+        it "creates a criteria from the parent scope" do
+          @parent.expects(:testing).returns(true)
+          @scope.testing.should be_true
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#respond_to?" do
+
+    context "when parent is a class" do
+
+      before do
+        @scope = Humanoid::Scope.new(Person, {})
+      end
+
+      it "delegates to the target" do
+        @scope.respond_to?(:only).should be_true
+      end
+
+    end
+
+    context "when parent is a scope" do
+
+      before do
+        @parent = Humanoid::Scope.new(Person, {})
+        @scope = Humanoid::Scope.new(@parent, {})
+      end
+
+      it "delegates to the parent" do
+        @scope.respond_to?(:only).should be_true
+      end
+
+    end
+
+  end
+
+  describe "#scopes" do
+
+    before do
+      @parent = mock
+      @scope = Humanoid::Scope.new(@parent, {})
+    end
+
+    it "delegates to the parent" do
+      @parent.expects(:scopes).returns({})
+      @scope.scopes.should == {}
+    end
+
+  end
+
+  describe "#target" do
+
+    before do
+      @scope = Humanoid::Scope.new(Person, { :where => { :title => "Sir" } })
+    end
+
+    it "returns the conditions criteria" do
+      @scope.target.selector.should ==
+        { :title => "Sir" }
+    end
+
+  end
+
+end

data/spec/unit/mongoid/timestamps_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Humanoid::Timestamps do
+
+  describe ".included" do
+
+    before do
+      @person = Person.new
+    end
+
+    it "adds created_at and updated_at to the document" do
+      fields = Person.fields
+      fields["created_at"].should_not be_nil
+      fields["updated_at"].should_not be_nil
+    end
+
+    it "forces the timestamps to UTC" do
+      @person.run_callbacks(:before_save)
+      @person.created_at.should be_close(Time.now.utc, 10.seconds)
+      @person.updated_at.should be_close(Time.now.utc, 10.seconds)
+    end
+
+  end
+
+end