rspec-solr 0.0.1

data/spec/include_in_first_n_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+require 'rspec-solr'
+
+describe RSpecSolr do
+  
+  # fixtures below
+  
+  context "#include().in_first(n)" do
+    context "should include().in_first(n)" do
+      it "passes when include arg is String and doc meets criteria" do
+        @solr_resp_5_docs.should include("222").in_first(3)
+        @solr_resp_5_docs.should include("111").in_first(1)
+        @solr_resp_5_docs.should include("222").in_first(2)
+      end
+      it "fails when include arg is String but doc comes too late" do
+        lambda {
+          @solr_resp_5_docs.should include("222").in_first(1)
+        }.should fail_matching('} to include document "222" in first 1')
+      end
+      it "passes when include arg is Hash and doc meets criteria" do
+        @solr_resp_5_docs.should include("fld" => ["val1", "val2", "val3"]).in_first(4)
+      end
+      it "fails when include arg is Hash but doc comes too late" do
+        lambda {
+          @solr_resp_5_docs.should include("fld" => ["val1", "val2", "val3"]).in_first(2)
+        }.should fail_matching('} to include document {"fld"=>["val1", "val2", "val3"]} in first 2')
+      end
+      it "passes when include arg is Array and all docs meet criteria" do
+        @solr_resp_5_docs.should include(["111", "222"]).in_first(2)
+        @solr_resp_5_docs.should include(["333", {"fld2"=>"val2"}]).in_first(4)
+      end
+      it "fails when include arg is Array but at least one doc comes too late" do
+        lambda {
+          @solr_resp_5_docs.should include(["111", "444"]).in_first(2)
+        }.should fail_matching('} to include documents ["111", "444"] in first 2')
+        lambda {
+          @solr_resp_5_docs.should include(["333", {"fld2"=>"val2"}]).in_first(2)
+        }.should fail_matching('} to include documents ["333", {"fld2"=>"val2"}] in first 2')
+      end
+      it "fails when there is no matching result" do
+        lambda {        
+          @solr_resp_5_docs.should include("666").in_first(6)
+        }.should fail_matching('} to include document "666" in first 6')
+        lambda {
+          @solr_resp_5_docs.should include("fld"=>"not there").in_first(3)
+        }.should fail_matching('} to include document {"fld"=>"not there"} in first 3')
+        lambda {
+          @solr_resp_5_docs.should include("666", "777").in_first(6)
+        }.should fail_matching('} to include documents "666" and "777" in first 6')
+      end
+    end # should include().in_first(n)
+
+    context "should_NOT include().in_first(n)" do
+      it "fails when include arg is String and doc meets criteria" do
+        lambda {
+          @solr_resp_5_docs.should_not include("222").in_first(2)
+        }.should fail_matching('not to include document "222" in first 2')
+      end
+      it "passes when include arg is String but doc comes too late" do
+        @solr_resp_5_docs.should_not include("222").in_first(1)
+      end
+      it "fails when include arg is Hash and doc meets criteria" do
+        lambda {
+          @solr_resp_5_docs.should_not include("fld" => ["val1", "val2", "val3"]).in_first(4)
+        }.should fail_matching('not to include document {"fld"=>["val1", "val2", "val3"]} in first 4')
+      end
+      it "passes when include arg is Hash but doc comes too late" do
+        @solr_resp_5_docs.should_not include("fld" => ["val1", "val2", "val3"]).in_first(2)
+      end
+      it "fails when include arg is Array and all docs meet criteria" do
+        lambda {
+          @solr_resp_5_docs.should_not include("111", "222").in_first(2)
+        }.should fail_matching('not to include documents "111" and "222" in first 2')
+        lambda {
+          @solr_resp_5_docs.should_not include(["333", {"fld2"=>"val2"}]).in_first(4)
+        }.should fail_matching('not to include documents ["333", {"fld2"=>"val2"}] in first 4')
+      end
+      it "passes when include arg is Array but at least one doc comes too late" do
+        @solr_resp_5_docs.should_not include(["111", "444"]).in_first(2)
+        @solr_resp_5_docs.should_not include(["333", {"fld2"=>"val2"}]).in_first(2)
+      end
+      it "passes when there is no matching result" do
+        @solr_resp_5_docs.should_not include("666").in_first(6)
+        @solr_resp_5_docs.should_not include("fld"=>"not there").in_first(3)
+        @solr_resp_5_docs.should_not include("666", "777").in_first(6)
+      end      
+    end # should_NOT include().in_first(n)    
+  end # include().in_first(n)
+  
+  context "#include().in_first (no n set) implies n=1" do
+    context "should #include().in_first" do
+      it "passes when matching document is first" do
+        @solr_resp_5_docs.should include("111").in_first
+      end
+      it "fails when matching document is not first" do
+        lambda {
+          @solr_resp_5_docs.should include("fld"=>["val1", "val2", "val3"]).in_first
+        }.should fail_matching('} to include document {"fld"=>["val1", "val2", "val3"]} in first 1')
+      end
+    end
+    context "should_NOT include().in_first" do
+      it "fails when matching document is first" do
+        lambda {
+          @solr_resp_5_docs.should_not include("111").in_first
+        }.should fail_matching('not to include document "111" in first 1')
+      end
+      it "passes when matching document is not first" do
+        @solr_resp_5_docs.should_not include("fld"=>["val1", "val2", "val3"]).in_first
+      end
+    end
+  end # include().in_first (no n set)
+  
+  context "#include().in_first(n).any_chained.names" do
+    context "should #include().in_first(n).any_chained.names" do
+      it "passes when document(s) meet criteria" do
+        @solr_resp_5_docs.should include("222").in_first(2).results
+        @solr_resp_5_docs.should include("222").in_first(2).documents
+        @solr_resp_5_docs.should include("222").in_first(2).solr.documents
+        @solr_resp_5_docs.should include("fld2"=>"val2").in_first.solr.document
+      end
+      it "fails when document(s) don't meet criteria" do
+        lambda {
+          @solr_resp_5_docs.should include("fld"=>["val1", "val2", "val3"]).in_first.result
+        }.should fail_matching('} to include document {"fld"=>["val1", "val2", "val3"]} in first 1')
+      end
+    end
+    context "should_NOT #include().in_first(n).any_chained.names" do
+      it "fails when document(s) meet criteria" do
+        lambda {
+          @solr_resp_5_docs.should_not include("222").in_first(2).solr.documents
+        }.should fail_matching('not to include document "222" in first 2 ')
+        lambda {
+          @solr_resp_5_docs.should_not include("fld2"=>"val2").in_first.solr.document
+        }.should fail_matching('not to include document {"fld2"=>"val2"} in first 1')
+      end
+      it "passes when document(s) don't meet criteria" do
+        @solr_resp_5_docs.should_not include("fld"=>["val1", "val2", "val3"]).in_first.result
+      end
+    end
+  end # include().in_first().any_chained_names
+  
+  context "#include().as_first" do
+    context "should include().as_first" do
+      it "passes when the first document meets the criteria" do
+        @solr_resp_5_docs.should include("111").as_first
+        @solr_resp_5_docs.should include("fld"=>"val").as_first
+        @solr_resp_5_docs.should include("fld"=>"val", "fld2"=>"val2").as_first
+      end
+      it "fails when a document meets the criteria but is not the first" do
+        lambda {
+          @solr_resp_5_docs.should include("222").as_first
+        }.should fail_matching('} to include document "222" in first 1')
+        lambda {
+          @solr_resp_5_docs.should include("fld" => ["val1", "val2", "val3"]).as_first
+          }.should fail_matching('} to include document {"fld"=>["val1", "val2", "val3"]} in first 1')
+      end
+      it "fails when there is no matching result" do
+        lambda {
+          @solr_resp_5_docs.should include("96").as_first
+          }.should fail_matching('} to include document "96" in first 1')
+      end    
+    end
+    context "should_NOT include().as_first" do
+      it "fails when the first document meets the criteria" do
+        lambda {
+          @solr_resp_5_docs.should_not include("111").as_first
+        }.should fail_matching('not to include document "111" in first 1')
+        lambda {
+          @solr_resp_5_docs.should_not include("fld"=>"val").as_first
+        }.should fail_matching('not to include document {"fld"=>"val"} in first 1')
+        lambda {
+          @solr_resp_5_docs.should_not include("fld"=>"val", "fld2"=>"val2").as_first
+        }.should fail_matching('not to include document {"fld"=>"val", "fld2"=>"val2"} in first 1')
+      end
+      it "passes when a document meets the criteria but is not the first" do
+        @solr_resp_5_docs.should_not include("222").as_first.document
+        @solr_resp_5_docs.should_not include("fld" => ["val1", "val2", "val3"]).as_first
+      end
+      it "passes when there is no matching result" do
+        @solr_resp_5_docs.should_not include("96").as_first
+      end    
+    end
+  end
+  
+  
+  context "#include().as_first().any_chained.names" do
+    context "should #include().as_first(n).any_chained.names" do
+      it "passes when document(s) meet criteria" do
+        @solr_resp_5_docs.should include(["111", "222"]).as_first(2).results
+        @solr_resp_5_docs.should include(["111", "222"]).as_first(2).solr.documents
+        @solr_resp_5_docs.should include("fld2"=>"val2").as_first.solr.document
+      end
+      it "fails when document(s) don't meet criteria" do
+        lambda {
+          @solr_resp_5_docs.should include("fld"=>["val1", "val2", "val3"]).as_first.result
+        }.should fail_matching ('} to include document {"fld"=>["val1", "val2", "val3"]} in first 1')
+      end
+    end
+    context "should_NOT #include().as_first(n).any_chained.names" do
+      it "fails when document(s) meet criteria" do
+        lambda {
+          @solr_resp_5_docs.should_not include(["111", "222"]).as_first(2).solr.documents
+        }.should fail_matching('not to include documents ["111", "222"] in first 2')
+        lambda {
+          @solr_resp_5_docs.should_not include("fld2"=>"val2").as_first.solr.document
+        }.should fail_matching('not to include document {"fld2"=>"val2"} in first 1')
+      end
+      it "passes when document(s) don't meet criteria" do
+        @solr_resp_5_docs.should_not include("fld"=>["val1", "val2", "val3"]).as_first.result
+      end
+    end
+  end # include().as_first().any_chained_names
+
+  before(:all) do
+    @solr_resp_5_docs = RSpecSolr::SolrResponseHash.new({ "response" =>
+                          { "numFound" => 5, 
+                            "start" => 0, 
+                            "docs" => 
+                              [ {"id"=>"111", "fld"=>"val", "fld2"=>"val2"}, 
+                                {"id"=>"222"}, 
+                                {"id"=>"333", "fld"=>"val"}, 
+                                {"id"=>"444", "fld"=>["val1", "val2", "val3"]}, 
+                                {"id"=>"555"}
+                              ]
+                          }
+                        })
+  end
+  
+end

data/spec/number_of_documents_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+require 'rspec-solr'
+
+describe RSpecSolr do
+
+  context "shouldn't break RSpec #have matcher" do
+    it "for Array" do
+      [1,2,3].should have(3).items
+      [1,2,3].should_not have(4).items
+      [1,2,3].should have_at_least(2).items
+      [1,2,3].should have_at_least(1).item
+      [1,2,3].should have_at_most(5).items
+    end
+    
+    it "for Hash" do
+      {:k1 => 'v1', :k2 => 'v2', :k3 => 'v3'}.should have_exactly(3).items
+      {:k1 => 'v1', :k2 => 'v2', :k3 => 'v3'}.should_not have(4).items
+      {:k1 => 'v1', :k2 => 'v2', :k3 => 'v3'}.should have_at_least(2).items
+      {:k1 => 'v1', :k2 => 'v2', :k3 => 'v3'}.should have_at_most(5).items
+    end
+    
+    it "for String" do
+      "this string".should have(11).characters
+      "this string".should_not have(12).characters
+    end
+    
+    it "passes args to target" do
+      target = mock("target")
+      target.should_receive(:items).with("arg1","arg2").and_return([1,2,3])
+      target.should have(3).items("arg1","arg2")
+    end
+    it "passes block to target" do
+          target = mock("target")
+          block = lambda { 5 }
+          target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3])
+          target.should have(3).items("arg1","arg2", block)
+    end
+  end
+  
+  # fixtures at end of this file
+
+  context "should have(n).documents" do
+    
+    it "pluralizes 'documents'" do
+      @solr_resp_1_doc.should have(1).document
+    end
+    
+    it "passes if target response has n documents" do
+      @solr_resp_5_docs.should have(5).documents
+      @solr_resp_no_docs.should have(0).documents
+    end
+    
+    it "converts :no to 0" do
+      @solr_resp_no_docs.should have(:no).documents
+    end
+    
+    it "converts a String argument to Integer" do
+      @solr_resp_5_docs.should have('5').documents
+    end
+    
+    it "fails if target response has < n documents" do
+      lambda {
+        @solr_resp_5_docs.should have(6).documents
+      }.should fail_with("expected 6 documents, got 5")
+      lambda {
+        @solr_resp_no_docs.should have(1).document
+      }.should fail_with("expected 1 document, got 0")
+    end
+    
+    it "fails if target response has > n documents" do
+      lambda {
+        @solr_resp_5_docs.should have(4).documents
+      }.should fail_with("expected 4 documents, got 5")
+      lambda {
+        @solr_resp_1_doc.should have(0).documents
+      }.should fail_with("expected 0 documents, got 1")
+    end
+    
+  end
+  
+  context "should_not have(n).documents" do
+    it "passes if target response has < n documents" do
+      @solr_resp_5_docs.should_not have(6).documents
+      @solr_resp_1_doc.should_not have(2).documents
+      @solr_resp_no_docs.should_not have(1).document
+    end
+    
+    it "passes if target response has > n documents" do
+      @solr_resp_5_docs.should_not have(4).documents
+      @solr_resp_1_doc.should_not have(0).documents
+      @solr_resp_no_docs.should_not have(-1).documents
+    end
+    
+    it "fails if target response has n documents" do
+      lambda {
+        @solr_resp_5_docs.should_not have(5).documents
+      }.should fail_with("expected target not to have 5 documents, got 5")
+    end
+  end
+  
+  context "should have_exactly(n).documents" do
+    it "passes if target response has n documents" do
+      @solr_resp_5_docs.should have_exactly(5).documents
+      @solr_resp_no_docs.should have_exactly(0).documents
+    end
+    it "converts :no to 0" do
+      @solr_resp_no_docs.should have_exactly(:no).documents
+    end
+    it "fails if target response has < n documents" do
+      lambda {
+        @solr_resp_5_docs.should have_exactly(6).documents
+      }.should fail_with("expected 6 documents, got 5")
+      lambda {
+        @solr_resp_no_docs.should have_exactly(1).document
+      }.should fail_with("expected 1 document, got 0")
+    end
+    
+    it "fails if target response has > n documents" do
+      lambda {
+        @solr_resp_5_docs.should have_exactly(4).documents
+      }.should fail_with("expected 4 documents, got 5")
+      lambda {
+        @solr_resp_1_doc.should have_exactly(0).documents
+      }.should fail_with("expected 0 documents, got 1")
+    end
+  end
+  
+  context "should have_at_least(n).documents" do
+    it "passes if target response has n documents" do
+      @solr_resp_5_docs.should have_at_least(5).documents
+      @solr_resp_1_doc.should have_at_least(1).document
+      @solr_resp_no_docs.should have_at_least(0).documents
+    end
+    
+    it "passes if target response has > n documents" do
+      @solr_resp_5_docs.should have_at_least(4).documents
+      @solr_resp_1_doc.should have_at_least(0).documents
+    end
+    
+    it "fails if target response has < n documents" do
+      lambda {
+        @solr_resp_5_docs.should have_at_least(6).documents
+      }.should fail_matching("expected at least 6 documents, got 5")
+      lambda {
+        @solr_resp_no_docs.should have_at_least(1).document
+      }.should fail_matching("expected at least 1 document, got 0")
+    end
+    
+    it "provides educational negative failure messages" do
+      # given
+      my_matcher = have_at_least(6).documents
+      # when
+      my_matcher.matches?(@solr_resp_5_docs)
+      # then 
+      my_matcher.failure_message_for_should_not.should eq <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_least(6).documents
+We recommend that you use this instead:
+  should have_at_most(5).documents
+EOF
+    end
+  end
+    
+  context "should have_at_most(n).documents" do
+    it "passes if target response has n documents" do
+      @solr_resp_5_docs.should have_at_most(5).documents
+      @solr_resp_1_doc.should have_at_most(1).document
+      @solr_resp_no_docs.should have_at_most(0).documents
+    end
+
+    it "passes if target response has < n documents" do
+      @solr_resp_5_docs.should have_at_most(6).documents
+      @solr_resp_no_docs.should have_at_most(1).document
+    end
+
+    it "fails if target response has > n documents" do
+      lambda {
+        @solr_resp_5_docs.should have_at_most(4).documents
+      }.should fail_matching("expected at most 4 documents, got 5")
+      lambda {
+        @solr_resp_1_doc.should have_at_most(0).documents
+      }.should fail_matching("expected at most 0 documents, got 1")
+    end
+
+    it "provides educational negative failure messages" do
+      # given
+      my_matcher = have_at_most(4).documents
+      # when
+      my_matcher.matches?(@solr_resp_5_docs)
+      # then 
+      my_matcher.failure_message_for_should_not.should eq <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+  should_not have_at_most(4).documents
+We recommend that you use this instead:
+  should have_at_least(5).documents
+EOF
+    end
+  end
+  
+  it "should pass according to total Solr docs matching the query, not the number of docs in THIS response" do
+    solr_resp = RSpecSolr::SolrResponseHash.new({ "response" =>
+                          { "numFound" => 3, 
+                            "start" => 0, 
+                            "rows" => 1,
+                            "docs" => [ {"id"=>"111"} ]
+                          }
+                        })
+    solr_resp.should have(3).documents
+    solr_resp.should_not have(1).document
+    solr_resp = RSpecSolr::SolrResponseHash.new({ "response" =>
+                          { "numFound" => 3, 
+                            "start" => 0, 
+                            "rows" => 0 
+                          }
+                        })
+    solr_resp.should have(3).documents
+  end
+  
+  before(:all) do
+    @solr_resp_1_doc = RSpecSolr::SolrResponseHash.new({ "response" =>
+                          { "numFound" => 1, 
+                            "start" => 0, 
+                            "docs" => [ {"id"=>"111"} ]
+                          }
+                        })
+
+    @solr_resp_5_docs = RSpecSolr::SolrResponseHash.new({ "response" =>
+                          { "numFound" => 5, 
+                            "start" => 0, 
+                            "docs" => 
+                              [ {"id"=>"111"}, 
+                                {"id"=>"222"}, 
+                                {"id"=>"333"}, 
+                                {"id"=>"444"}, 
+                                {"id"=>"555"}
+                              ]
+                          }
+                        })
+
+    @solr_resp_no_docs = RSpecSolr::SolrResponseHash.new({ "response" =>
+                          { "numFound" => 0, 
+                            "start" => 0, 
+                            "docs" => [] 
+                          }
+                        }) 
+  end
+  
+end

data/spec/solr_response_hash_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'rspec-solr'
+
+describe RSpecSolr::SolrResponseHash do
+  
+  context "id field" do
+    before(:all) do
+      @srh = RSpecSolr::SolrResponseHash.new({ "response" =>
+                            { "docs" => 
+                                [ {"id"=>"111"}, 
+                                  {"not_id"=>"222"}, 
+                                  {"id"=>"333"}, 
+                                ]
+                            }
+                          })
+    end
+    it "should default to 'id'" do
+      RSpecSolr::SolrResponseHash.new({}).id_field.should == "id"
+      @srh.id_field.should == "id"
+    end
+    it "should be changable to whatever" do
+      @srh.id_field='new'
+      @srh.id_field.should == 'new'
+      @srh.id_field='newer'
+      @srh.id_field.should == 'newer'
+    end
+  end
+  
+  # fixture below
+  
+  context "has_document?" do
+    it "should be true when single document meets expectation" do
+      @solr_resp_5_docs.should have_document({"id" => "222"})
+      @solr_resp_5_docs.should have_document({"id" => "111", "fld" => "val"})
+    end
+    
+    it "should be true when at least one doc meets expectation" do
+      @solr_resp_5_docs.should have_document({"fld" => "val"})
+    end
+    
+    it "should be false when no docs meet expectation" do
+      @solr_resp_5_docs.should_not have_document({"id" => "not_there"})
+    end
+    
+    it "should be false when only part of expectation is met" do
+      @solr_resp_5_docs.should_not have_document({"id" => "222", "fld" => "val"})
+    end  
+    
+    it "should be true when document is < =  expected position in results" do
+      @solr_resp_5_docs.should have_document({"id" => "222"}, 2)
+    end
+    
+    it "should be false when document is > expected position in results" do
+      @solr_resp_5_docs.should_not have_document({"id" => "222"}, 1)
+    end
+     
+  end  # has_document?
+  
+  context "get_first_doc_index" do
+    it "should get the right document index with an id String argument" do
+      @solr_resp_5_docs.get_first_doc_index("333").should == 2
+      @solr_resp_5_docs.get_first_doc_index("111").should == 0
+    end
+    
+    it "should get the first occurrence of a doc meeting a Hash argument" do
+      @solr_resp_5_docs.get_first_doc_index("fld"=>"val").should == 0
+      @solr_resp_5_docs.get_first_doc_index("id"=>"333").should == 2
+    end
+    
+    it "should get the index of the doc occurring first in the results from an Array argument" do
+      @solr_resp_5_docs.get_first_doc_index(["fld"=>"val"]).should == 0
+      @solr_resp_5_docs.get_first_doc_index(["222", "444"]).should == 1
+    end
+    
+    it "should return nil when the expectation argument isn't met" do
+      @solr_resp_5_docs.get_first_doc_index("666").should be_nil
+      @solr_resp_5_docs.get_first_doc_index("not_there"=>"not_there").should be_nil
+      @solr_resp_5_docs.get_first_doc_index(["222", "666"]).should be_nil
+    end
+    
+  end
+  
+  context "get_min_index" do    
+    it "should return nil when both arguments are nil" do
+      @solr_resp_5_docs.send(:get_min_index, nil, nil).should be_nil
+    end
+    it "should return the first argument when the second argument is nil" do
+      @solr_resp_5_docs.send(:get_min_index, 3, nil).should == 3
+    end
+    it "should return the second argument when the first argument is nil" do
+      @solr_resp_5_docs.send(:get_min_index, nil, 5).should == 5
+    end
+    it "should return the minimum of the two arguments when neither of them is nil" do
+      @solr_resp_5_docs.send(:get_min_index, 2, 5).should == 2
+      @solr_resp_5_docs.send(:get_min_index, 5, 2).should == 2
+    end    
+  end
+  
+  
+  before(:all) do
+    @solr_resp_5_docs = RSpecSolr::SolrResponseHash.new({ "response" =>
+                          { "numFound" => 5, 
+                            "start" => 0, 
+                            "docs" => 
+                              [ {"id"=>"111", "fld"=>"val"}, 
+                                {"id"=>"222"}, 
+                                {"id"=>"333", "fld"=>"val"}, 
+                                {"id"=>"444"}, 
+                                {"id"=>"555"}
+                              ]
+                          }
+                        })
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# for test coverage
+require 'simplecov'
+require 'simplecov-rcov'
+class SimpleCov::Formatter::MergedFormatter
+  def format(result)
+     SimpleCov::Formatter::HTMLFormatter.new.format(result)
+     SimpleCov::Formatter::RcovFormatter.new.format(result)
+  end
+end
+SimpleCov.formatter = SimpleCov::Formatter::MergedFormatter
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+
+Dir['./spec/support/**/*'].each {|f| require f}
+
+#RSpec.configure do |config|
+#end

data/spec/support/matchers.rb

@@ -0,0 +1,22 @@
+# This file shamelessly copied from rspec-expecations/spec/support/matchers.rb
+RSpec::Matchers.define :include_method do |expected|
+  match do |actual|
+    actual.map { |m| m.to_s }.include?(expected.to_s)
+  end
+end
+
+module RSpec
+  module Matchers
+    def fail
+      raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+    def fail_with(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+    end
+
+    def fail_matching(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, /#{Regexp.escape(message)}/)
+    end
+  end
+end