mspec 1.0.0 → 1.1.0

data/spec/matchers/equal_spec.rb

@@ -22,12 +22,12 @@ describe EqualMatcher do
   it "provides a useful failure message" do
     matcher = EqualMatcher.new("red")
     matcher.matches?("red")
-    matcher.failure_message.should == ["Expected \"red\"", "to be identical to \"red\""]
+    matcher.failure_message.should == ["Expected \"red\"\n", "to be identical to \"red\"\n"]
   end
 
   it "provides a useful negative failure message" do
     matcher = EqualMatcher.new(1)
     matcher.matches?(1)
-    matcher.negative_failure_message.should == ["Expected 1", "not to be identical to 1"]
+    matcher.negative_failure_message.should == ["Expected 1\n", "not to be identical to 1\n"]
   end
 end

data/spec/matchers/equal_utf16_spec.rb

@@ -36,12 +36,12 @@ describe EqualUtf16Matcher do
   it "provides a useful failure message" do
     matcher = EqualUtf16Matcher.new("a\0b\0")
     matcher.matches?("a\0b\0c\0")
-    matcher.failure_message.should == ["Expected \"a\\000b\\000c\\000\"", "to equal \"a\\000b\\000\" or \"\\000a\\000b\""]
+    matcher.failure_message.should == ["Expected \"a\\000b\\000c\\000\"\n", "to equal \"a\\000b\\000\"\n or \"\\000a\\000b\"\n"]
   end
 
   it "provides a useful negative failure message" do
     matcher = EqualUtf16Matcher.new("a\0b\0")
     matcher.matches?("\0a\0b")
-    matcher.negative_failure_message.should == ["Expected \"\\000a\\000b\"", "not to equal \"a\\000b\\000\" nor \"\\000a\\000b\""]
+    matcher.negative_failure_message.should == ["Expected \"\\000a\\000b\"\n", "not to equal \"a\\000b\\000\"\n nor \"\\000a\\000b\"\n"]
   end
 end

data/spec/matchers/match_yaml_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/match_yaml'
+
+describe MatchYAMLMatcher do
+  before :each do
+    @matcher = MatchYAMLMatcher.new("--- \nfoo: bar\n")
+  end
+
+  it "compares YAML documents and matches if they're equivalent" do
+      @matcher.matches?("--- \nfoo: bar\n").should == true
+  end
+
+  it "compares YAML documents and does not match if they're not equivalent" do
+      @matcher.matches?("--- \nbar: foo\n").should == false
+      @matcher.matches?("--- \nfoo: \nbar\n").should == false  
+  end
+
+  it "also receives objects that respond_to to_yaml" do
+    matcher = MatchYAMLMatcher.new("some string")
+    matcher.matches?("some string").should == true
+
+    matcher = MatchYAMLMatcher.new(['a', 'b'])
+    matcher.matches?("--- \n- a\n- b\n").should == true
+
+    matcher = MatchYAMLMatcher.new("foo" => "bar")
+    matcher.matches?("--- \nfoo: bar\n").should == true
+  end
+
+  it "matches documents with trailing whitespace" do
+    @matcher.matches?("--- \nfoo: bar   \n").should == true
+    @matcher.matches?("---       \nfoo: bar   \n").should == true
+  end
+
+  it "fails with a descriptive error message" do
+    @matcher.matches?("foo").should == false
+    @matcher.failure_message.should == ["Expected \"foo\"", " to match \"--- \\nfoo: bar\\n\""]
+  end
+end

data/spec/mocks/mock_spec.rb

@@ -7,23 +7,68 @@ require 'mspec/runner/mspec'
 require 'mspec/mocks/mock'
 require 'mspec/mocks/proxy'
 
-describe Mock do
-  after :each do
-    Mock.cleanup
+describe Mock, ".mocks" do
+  it "returns a Hash" do
+    Mock.mocks.should be_kind_of(Hash)
   end
+end
 
-  it "provides expects that returns a Hash" do
-    Mock.expects.should be_an_instance_of(Hash)
+describe Mock, ".stubs" do
+  it "returns a Hash" do
+    Mock.stubs.should be_kind_of(Hash)
   end
 end
 
 describe Mock, ".replaced_name" do
   it "returns the name for a method that is being replaced by a mock method" do
-    Mock.replaced_name(:method_call).should == :__ms_method_call__
+    m = mock('a fake id')
+    m.stub!(:__id__).and_return(42)
+    Mock.replaced_name(m, :method_call).should == :__ms_42_method_call__
   end
 end
 
-describe Mock, ".install_method" do
+describe Mock, ".replaced_key" do
+  it "returns a key used internally by Mock" do
+    m = mock('a fake id')
+    m.stub!(:__id__).and_return(42)
+    Mock.replaced_key(m, :method_call).should == [:__ms_42_method_call__, m, :method_call]
+  end
+end
+
+describe Mock, ".replaced?" do
+  before :each do
+    @mock = mock('install_method')
+    MSpec.stub!(:actions)
+    MSpec.stub!(:current).and_return(mock("spec state", :null_object => true))
+  end
+
+  it "returns true if a method has been stubbed on an object" do
+    Mock.install_method @mock, :method_call
+    Mock.replaced?(Mock.replaced_key(@mock, :method_call)).should be_true
+  end
+
+  it "returns true if a method has been mocked on an object" do
+    Mock.install_method @mock, :method_call, :stub
+    Mock.replaced?(Mock.replaced_key(@mock, :method_call)).should be_true
+  end
+
+  it "returns false if a method has not been stubbed or mocked" do
+    Mock.replaced?(Mock.replaced_key(@mock, :method_call)).should be_false
+  end
+end
+
+describe Mock, ".name_or_inspect" do
+  before :each do
+    @mock = mock("I have a #name")
+  end
+
+  it "returns the value of @name if set" do
+    @mock.instance_variable_set(:@name, "Myself")
+    Mock.name_or_inspect(@mock).should == "Myself"
+  end
+end
+
+describe Mock, ".install_method for mocks" do
   before :each do
     @mock = mock('install_method')
     MSpec.stub!(:actions)
@@ -38,11 +83,6 @@ describe Mock, ".install_method" do
     Mock.install_method(@mock, :method_call).should be_an_instance_of(MockProxy)
   end
 
-  it "sets the proxy to expect exactly 1 call" do
-    proxy = Mock.install_method(@mock, :method_call)
-    proxy.count.should == [:exactly, 1]
-  end
-
   it "does not override a previously mocked method with the same name" do
     Mock.install_method(@mock, :method_call).with(:a, :b).and_return(1)
     Mock.install_method(@mock, :method_call).with(:c).and_return(2)
@@ -51,6 +91,28 @@ describe Mock, ".install_method" do
     lambda { @mock.method_call(:d) }.should raise_error(ExpectationNotMetError)
   end
 
+  # This illustrates RSpec's behavior. This spec fails in mock call count verification
+  # on RSpec (i.e. Mock 'foo' expected :foo with (any args) once, but received it 0 times)
+  # and we mimic the behavior of RSpec.
+  #
+  # describe "A mock receiving multiple calls to #should_receive" do
+  #   it "returns the first value mocked" do
+  #     m = mock 'multiple #should_receive'
+  #     m.should_receive(:foo).and_return(true)
+  #     m.foo.should == true
+  #     m.should_receive(:foo).and_return(false)
+  #     m.foo.should == true
+  #   end
+  # end
+  #
+  it "does not override a previously mocked method having the same arguments" do
+    Mock.install_method(@mock, :method_call).with(:a).and_return(true)
+    @mock.method_call(:a).should == true
+    Mock.install_method(@mock, :method_call).with(:a).and_return(false)
+    @mock.method_call(:a).should == true
+    lambda { Mock.verify_count }.should raise_error(ExpectationNotMetError)
+  end
+
   it "properly sends #respond_to? calls to the aliased respond_to? method when not matching mock expectations" do
     Mock.install_method(@mock, :respond_to?).with(:to_str).and_return('mock to_str')
     Mock.install_method(@mock, :respond_to?).with(:to_int).and_return('mock to_int')
@@ -66,6 +128,74 @@ describe Mock, ".install_method" do
     MSpec.should_receive(:current).and_return(state)
     MSpec.should_receive(:actions).with(:expectation, state.state)
     Mock.install_method(@mock, :method_call).and_return(1)
+    @mock.method_call.should == 1
+  end
+end
+
+describe Mock, ".install_method for stubs" do
+  before :each do
+    @mock = mock('install_method')
+    MSpec.stub!(:actions)
+    MSpec.stub!(:current).and_return(mock("spec state", :null_object => true))
+  end
+
+  after :each do
+    Mock.cleanup
+  end
+
+  it "returns a MockProxy instance" do
+    Mock.install_method(@mock, :method_call, :stub).should be_an_instance_of(MockProxy)
+  end
+
+  # This illustrates RSpec's behavior. This spec passes on RSpec and we mimic it
+  #
+  # describe "A mock receiving multiple calls to #stub!" do
+  #   it "returns the last value stubbed" do
+  #     m = mock 'multiple #stub!'
+  #     m.stub!(:foo).and_return(true)
+  #     m.foo.should == true
+  #     m.stub!(:foo).and_return(false)
+  #     m.foo.should == false
+  #   end
+  # end
+  it "inserts new stubs before old stubs" do
+    Mock.install_method(@mock, :method_call, :stub).with(:a).and_return(true)
+    @mock.method_call(:a).should == true
+    Mock.install_method(@mock, :method_call, :stub).with(:a).and_return(false)
+    @mock.method_call(:a).should == false
+    Mock.verify_count
+  end
+
+  it "does not add to the expectation tally" do
+    state = mock("run state", :null_object => true)
+    state.stub!(:state).and_return(mock("spec state"))
+    MSpec.should_not_receive(:actions)
+    Mock.install_method(@mock, :method_call, :stub).and_return(1)
+    @mock.method_call.should == 1
+  end
+end
+
+describe Mock, ".install_method" do
+  before :each do
+    @mock = mock('install_method')
+    MSpec.stub!(:actions)
+    MSpec.stub!(:current).and_return(mock("spec state", :null_object => true))
+  end
+
+  after :each do
+    Mock.cleanup
+  end
+
+  it "does not alias a mocked or stubbed method when installing a new mock or stub" do
+    @mock.should_not respond_to(:method_call)
+
+    Mock.install_method @mock, :method_call
+    @mock.should respond_to(:method_call)
+    @mock.should_not respond_to(Mock.replaced_name(@mock, :method_call))
+
+    Mock.install_method @mock, :method_call, :stub
+    @mock.should respond_to(:method_call)
+    @mock.should_not respond_to(Mock.replaced_name(@mock, :method_call))
   end
 end
 
@@ -113,25 +243,25 @@ describe Mock, ".verify_call" do
     @proxy.with(:any_args)
     Mock.verify_call @mock, :method_call, 1, 2, 3
   end
-  
+
   it "yields a passed block when it is expected to" do
     @proxy.and_yield()
-    Mock.verify_call @mock, :method_call do 
+    Mock.verify_call @mock, :method_call do
       ScratchPad.record true
     end
     ScratchPad.recorded.should == true
   end
-  
+
   it "does not yield a passed block when it is not expected to" do
-    Mock.verify_call @mock, :method_call do 
+    Mock.verify_call @mock, :method_call do
       ScratchPad.record true
     end
     ScratchPad.recorded.should == nil
   end
-  
+
   it "can yield subsequently" do
     @proxy.and_yield(1).and_yield(2).and_yield(3)
-    
+
     ScratchPad.record []
     Mock.verify_call @mock, :method_call do |arg|
       ScratchPad << arg
@@ -141,7 +271,7 @@ describe Mock, ".verify_call" do
 
   it "can yield and return an expected value" do
     @proxy.and_yield(1).and_return(3)
-    
+
     Mock.verify_call(@mock, :method_call) { |arg| ScratchPad.record arg }.should == 3
     ScratchPad.recorded.should == 1
   end
@@ -231,6 +361,38 @@ describe Mock, ".verify_count" do
   end
 end
 
+describe Mock, ".verify_count mixing mocks and stubs" do
+  before :each do
+    MSpec.stub!(:actions)
+    MSpec.stub!(:current).and_return(mock("spec state", :null_object => true))
+
+    @mock = mock('verify_count')
+  end
+
+  after :each do
+    Mock.cleanup
+  end
+
+  it "does not raise an exception for a stubbed method that is never called" do
+    Mock.install_method @mock, :method_call, :stub
+    Mock.verify_count
+  end
+
+  it "verifies the calls to the mocked method when a mock is defined after a stub" do
+    Mock.install_method @mock, :method_call, :stub
+    Mock.install_method @mock, :method_call, :mock
+    @mock.method_call
+    Mock.verify_count
+  end
+
+  it "verifies the calls to the mocked method when a mock is defined before a stub" do
+    Mock.install_method @mock, :method_call, :mock
+    Mock.install_method @mock, :method_call, :stub
+    @mock.method_call
+    Mock.verify_count
+  end
+end
+
 describe Mock, ".cleanup" do
   before :each do
     MSpec.stub!(:actions)
@@ -238,6 +400,7 @@ describe Mock, ".cleanup" do
 
     @mock = mock('cleanup')
     @proxy = Mock.install_method @mock, :method_call
+    @stub = Mock.install_method @mock, :method_call, :stub
   end
 
   after :each do
@@ -255,18 +418,23 @@ describe Mock, ".cleanup" do
     def @mock.already_here() :hey end
     @mock.should respond_to(:already_here)
     Mock.install_method @mock, :already_here
-    @mock.should respond_to(Mock.replaced_name(:already_here))
+    @mock.should respond_to(Mock.replaced_name(@mock, :already_here))
 
     Mock.cleanup
-    @mock.should_not respond_to(Mock.replaced_name(:already_here))
+    @mock.should_not respond_to(Mock.replaced_name(@mock, :already_here))
     @mock.should respond_to(:already_here)
     @mock.already_here.should == :hey
   end
 
   it "removes all mock expectations" do
-    Mock.expects.should == { [@mock, :method_call] => [@proxy] }
+    Mock.mocks.should == { Mock.replaced_key(@mock, :method_call) => [@proxy] }
+    Mock.cleanup
+    Mock.mocks.should == {}
+  end
 
+  it "removes all stubs" do
+    Mock.stubs.should == { Mock.replaced_key(@mock, :method_call) => [@stub] }
     Mock.cleanup
-    Mock.expects.should == {}
+    Mock.stubs.should == {}
   end
 end

data/spec/mocks/proxy_spec.rb

@@ -1,21 +1,54 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'mspec/mocks/proxy'
 
-describe MockProxy, "reporting method" do
+describe MockObject, ".new" do
+  it "creates a new mock object" do
+    m = MockObject.new('not a null object')
+    lambda { m.not_a_method }.should raise_error(NoMethodError)
+  end
+
+  it "creates a new mock object that follows the NullObject pattern" do
+    m = MockObject.new('null object', :null_object => true)
+    m.not_really_a_method.should equal(m)
+  end
+end
+
+describe MockProxy, ".new" do
+  it "creates a mock proxy by default" do
+    MockProxy.new.mock?.should be_true
+  end
+
+  it "creates a stub proxy by request" do
+    MockProxy.new(:stub).stub?.should be_true
+  end
+
+  it "sets the call expectation to 1 call for a mock" do
+    MockProxy.new.count.should == [:exactly, 1]
+  end
+
+  it "sets the call expectation to any number of times for a stub" do
+    MockProxy.new(:stub).count.should == [:any_number_of_times, 0]
+  end
+end
+
+describe MockProxy, "#count" do
   before :each do
     @proxy = MockProxy.new
   end
 
-  it "returns the expected number of calls the mock should receive with #count" do
-    @proxy.count.should == [:exactly, 0]
+  it "returns the expected number of calls the mock should receive" do
+    @proxy.count.should == [:exactly, 1]
+    @proxy.at_least(3).count.should == [:at_least, 3]
   end
+end
 
-  it "returns the expected arguments with #arguments" do
-    @proxy.arguments.should == :any_args
+describe MockProxy, "#arguments" do
+  before :each do
+    @proxy = MockProxy.new
   end
 
-  it "returns the expected return value with #returning" do
-    @proxy.returning.should == nil
+  it "returns the expected arguments" do
+    @proxy.arguments.should == :any_args
   end
 end
 
@@ -156,9 +189,9 @@ describe MockProxy, "#any_number_of_times" do
     @proxy.any_number_of_times.should be_equal(@proxy)
   end
 
-  it "sets the expected calls to at least 0" do
+  it "sets the expected calls to any number of times" do
     @proxy.any_number_of_times
-    @proxy.count.should == [:at_least, 0]
+    @proxy.count.should == [:any_number_of_times, 0]
   end
 
   it "does not accept an argument" do
@@ -172,7 +205,7 @@ describe MockProxy, "#and_return" do
   end
 
   it "returns self" do
-    @proxy.and_return(false).should be_equal(@proxy)
+    @proxy.and_return(false).should equal(@proxy)
   end
 
   it "sets the expected return value" do
@@ -192,7 +225,7 @@ describe MockProxy, "#and_return" do
     @proxy.count.should == [:exactly, 3]
   end
   
-  it "it only sets the expected number of calls if it is higher than what is already set" do
+  it "only sets the expected number of calls if it is higher than what is already set" do
     @proxy.at_least(5).times.and_return(1, 2, 3)
     @proxy.count.should == [:at_least, 5]
 
@@ -201,6 +234,32 @@ describe MockProxy, "#and_return" do
   end
 end
 
+describe MockProxy, "#returning" do
+  before :each do
+    @proxy = MockProxy.new
+  end
+
+  it "returns nil by default" do
+    @proxy.returning.should be_nil
+  end
+
+  it "returns the value set by #and_return" do
+    @proxy.and_return(2)
+    @proxy.returning.should == 2
+    @proxy.returning.should == 2
+  end
+
+  it "returns a sequence of values set by #and_return" do
+    @proxy.and_return(1,2,3,4)
+    @proxy.returning.should == 1
+    @proxy.returning.should == 2
+    @proxy.returning.should == 3
+    @proxy.returning.should == 4
+    @proxy.returning.should == 4
+    @proxy.returning.should == 4
+  end
+end
+
 describe MockProxy, "#calls" do
   before :each do
     @proxy = MockProxy.new
@@ -223,37 +282,85 @@ describe MockProxy, "#called" do
   end
 end
 
-describe MockProxy, "#returning" do
+describe MockProxy, "#times" do
   before :each do
     @proxy = MockProxy.new
   end
 
-  it "should return nil by default" do
-    @proxy.returning.should be_nil
+  it "is a no-op" do
+    @proxy.times.should == @proxy
   end
+end
 
-  it "should return the value set by #and_return" do
-    @proxy.and_return(2)
-    @proxy.returning.should == 2
+describe MockProxy, "#stub?" do
+  it "returns true if the proxy is created as a stub" do
+    MockProxy.new(:stub).stub?.should be_true
   end
 
-  it "should return a sequence of values set by #and_return" do
-    @proxy.and_return(1,2,3,4)
-    @proxy.returning.should == 1
-    @proxy.returning.should == 2
-    @proxy.returning.should == 3
-    @proxy.returning.should == 4
-    @proxy.returning.should == 4
-    @proxy.returning.should == 4
+  it "returns false if the proxy is created as a mock" do
+    MockProxy.new(:mock).stub?.should be_false
   end
 end
 
-describe MockProxy, "#times" do
+describe MockProxy, "#mock?" do
+  it "returns true if the proxy is created as a mock" do
+    MockProxy.new(:mock).mock?.should be_true
+  end
+
+  it "returns false if the proxy is created as a stub" do
+    MockProxy.new(:stub).mock?.should be_false
+  end
+end
+
+describe MockProxy, "#and_yield" do
   before :each do
     @proxy = MockProxy.new
   end
 
-  it "is a no-op" do
-    @proxy.times.should == @proxy
+  it "returns self" do
+    @proxy.and_yield(false).should equal(@proxy)
+  end
+
+  it "sets the expected values to yield" do
+    @proxy.and_yield(1).yielding.should == [[1]]
+  end
+
+  it "accepts multiple values to yield" do
+    @proxy.and_yield(1, 2, 3).yielding.should == [[1, 2, 3]]
+  end
+end
+
+describe MockProxy, "#yielding" do
+  before :each do
+    @proxy = MockProxy.new
+  end
+
+  it "returns an empty array by default" do
+    @proxy.yielding.should == []
+  end
+
+  it "returns an array of arrays of values the proxy should yield" do
+    @proxy.and_yield(3)
+    @proxy.yielding.should == [[3]]
+  end
+
+  it "returns an accumulation of arrays of values the proxy should yield" do
+    @proxy.and_yield(1).and_yield(2, 3)
+    @proxy.yielding.should == [[1], [2, 3]]
+  end
+end
+
+describe MockProxy, "#yielding?" do
+  before :each do
+    @proxy = MockProxy.new
+  end
+
+  it "returns false if the proxy is not yielding" do
+    @proxy.yielding?.should be_false
+  end
+
+  it "returns true if the proxy is yielding" do
+    @proxy.and_yield(1)
+    @proxy.yielding?.should be_true
   end
 end