spicycode-micronaut 0.0.2 → 0.0.3

data/examples/lib/micronaut/matchers/handler_example.rb

@@ -0,0 +1,146 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+module ExampleExpectations
+  
+  class ArbitraryMatcher
+    def initialize(*args, &block)
+      if args.last.is_a? Hash
+        @expected = args.last[:expected]
+      end
+      if block_given?
+        @expected = block.call
+      end
+      @block = block
+    end
+    
+    def matches?(target)
+      @target = target
+      return @expected == target
+    end
+    
+    def with(new_value)
+      @expected = new_value
+      self
+    end
+    
+    def failure_message
+      "expected #{@expected}, got #{@target}"
+    end
+    
+    def negative_failure_message
+      "expected not #{@expected}, got #{@target}"
+    end
+  end
+  
+  class PositiveOnlyMatcher < ArbitraryMatcher
+    undef negative_failure_message rescue nil
+  end
+  
+  def arbitrary_matcher(*args, &block)
+    ArbitraryMatcher.new(*args, &block)
+  end
+  
+  def positive_only_matcher(*args, &block)
+    PositiveOnlyMatcher.new(*args, &block)
+  end
+  
+end
+
+describe Micronaut::Expectations::ExpectationMatcherHandler do
+  describe "#handle_matcher" do
+    it "should ask the matcher if it matches" do
+      matcher = mock("matcher")
+      actual = Object.new
+      matcher.expects(:matches?).with(actual).returns(true)
+      Micronaut::Expectations::ExpectationMatcherHandler.handle_matcher(actual, matcher)
+    end
+  
+    it "should explain when the matcher parameter is not a matcher" do
+      begin
+        nonmatcher = mock("nonmatcher")
+        actual = Object.new
+        Micronaut::Expectations::ExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
+      rescue Micronaut::Expectations::InvalidMatcherError => e
+      end
+
+      e.message.should =~ /^Expected a matcher, got /
+    end
+    
+    it "should return the match value" do
+      matcher = mock("matcher")
+      actual = Object.new
+      matcher.expects(:matches?).with(actual).returns(:this_value)
+      Micronaut::Expectations::ExpectationMatcherHandler.handle_matcher(actual, matcher).should == :this_value
+    end
+  end
+end
+
+describe Micronaut::Expectations::NegativeExpectationMatcherHandler do
+  describe "#handle_matcher" do
+    it "should explain when matcher does not support should_not" do
+      matcher = mock("matcher")
+      matcher.stubs(:matches?)
+      actual = Object.new
+      lambda {
+        Micronaut::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
+      }.should fail_with(/Matcher does not support should_not.\n/)
+    end      
+  
+    it "should ask the matcher if it matches" do
+      matcher = mock("matcher")
+      actual = Object.new
+      matcher.stubs(:negative_failure_message)
+      matcher.expects(:matches?).with(actual).returns(false)
+      Micronaut::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher)
+    end
+  
+    it "should explain when the matcher parameter is not a matcher" do
+      begin
+        nonmatcher = mock("nonmatcher")
+        actual = Object.new
+        Micronaut::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, nonmatcher)
+      rescue Micronaut::Expectations::InvalidMatcherError => e
+      end
+
+      e.message.should =~ /^Expected a matcher, got /
+    end
+
+    
+    it "should return the match value" do
+      matcher = mock("matcher")
+      actual = Object.new
+      matcher.expects(:matches?).with(actual).returns(false)
+      matcher.stubs(:negative_failure_message).returns("ignore")
+      Micronaut::Expectations::NegativeExpectationMatcherHandler.handle_matcher(actual, matcher).should be_false
+    end
+  end
+end
+# 
+# describe Micronaut::Expectations::ExpectationMatcherHandler do
+#   include ExampleExpectations
+#   
+#   it "should handle submitted args" do
+#     5.should arbitrary_matcher(:expected => 5)
+#     5.should arbitrary_matcher(:expected => "wrong").with(5)
+#     lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
+#     lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
+#     5.should_not arbitrary_matcher(:expected => 4)
+#     5.should_not arbitrary_matcher(:expected => 5).with(4)
+#     lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
+#     lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
+#   end
+# 
+#   it "should handle the submitted block" do
+#     5.should arbitrary_matcher { 5 }
+#     5.should arbitrary_matcher(:expected => 4) { 5 }
+#     5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
+#   end
+# 
+#   it "should explain when matcher does not support should_not" do
+#     lambda {
+#       5.should_not positive_only_matcher(:expected => 5)
+#     }.should fail_with(/Matcher does not support should_not.\n/)
+#   end
+# 
+# 
+# end

data/examples/lib/micronaut/matchers/has_example.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe "should have_sym(*args)" do
+  it "should pass if #has_sym?(*args) returns true" do
+    {:a => "A"}.should have_key(:a)
+  end
+
+  it "should fail if #has_sym?(*args) returns false" do
+    lambda {
+      {:b => "B"}.should have_key(:a)
+    }.should fail_with("expected #has_key?(:a) to return true, got false")
+  end
+
+  it "should fail if target does not respond to #has_sym?" do
+    lambda {
+      Object.new.should have_key(:a)
+    }.should raise_error(NoMethodError)
+  end
+  
+  it "should reraise an exception thrown in #has_sym?(*args)" do
+    o = Object.new
+    def o.has_sym?(*args)
+      raise "Funky exception"
+    end
+    lambda { o.should have_sym(:foo) }.should raise_error("Funky exception")
+  end
+end
+
+describe "should_not have_sym(*args)" do
+  it "should pass if #has_sym?(*args) returns false" do
+    {:a => "A"}.should_not have_key(:b)
+  end
+
+  it "should fail if #has_sym?(*args) returns true" do
+    lambda {
+      {:a => "A"}.should_not have_key(:a)
+    }.should fail_with("expected #has_key?(:a) to return false, got true")
+  end
+
+  it "should fail if target does not respond to #has_sym?" do
+    lambda {
+      Object.new.should have_key(:a)
+    }.should raise_error(NoMethodError)
+  end
+  
+  it "should reraise an exception thrown in #has_sym?(*args)" do
+    o = Object.new
+    def o.has_sym?(*args)
+      raise "Funky exception"
+    end
+    lambda { o.should_not have_sym(:foo) }.should raise_error("Funky exception")
+  end
+end
+
+describe "has" do
+  it "should work when the target implements #send" do
+    o = {:a => "A"}
+    def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
+    lambda {
+      o.should have_key(:a)
+    }.should_not raise_error
+  end
+end