http_stub 0.13.5 → 0.14.0.rc1

data/spec/lib/http_stub/models/headers_spec.rb

@@ -4,8 +4,8 @@ describe HttpStub::Models::Headers do
 
   let(:headers) { HttpStub::Models::Headers.new(header_hash) }
 
-  it "should be a Hash" do
-    headers.should be_a(Hash)
+  it "is a Hash" do
+    expect(headers).to be_a(Hash)
   end
 
   describe "#to_s" do
@@ -14,14 +14,14 @@ describe HttpStub::Models::Headers do
 
       let(:header_hash) { { "key1" => "value1", "key2" => "value2", "key3" => "value3" } }
 
-      it "should return a string containing each header formatted as a conventional request header" do
+      it "returns a string containing each header formatted as a conventional request header" do
         result = headers.to_s
 
-        header_hash.each { |key, value| result.should match(/#{key}:#{value}/) }
+        header_hash.each { |key, value| expect(result).to match(/#{key}:#{value}/) }
       end
 
-      it "should comma delimit the headers" do
-        headers.to_s.should match(/key\d.value\d\, key\d.value\d\, key\d.value\d/)
+      it "comma delimits the headers" do
+        expect(headers.to_s).to match(/key\d.value\d\, key\d.value\d\, key\d.value\d/)
       end
 
     end
@@ -30,8 +30,8 @@ describe HttpStub::Models::Headers do
 
       let(:header_hash) { {} }
 
-      it "should return an empty string" do
-        headers.to_s.should eql("")
+      it "returns an empty string" do
+        expect(headers.to_s).to eql("")
       end
 
     end
@@ -40,8 +40,8 @@ describe HttpStub::Models::Headers do
 
       let(:header_hash) { nil }
 
-      it "should return an empty string" do
-        headers.to_s.should eql("")
+      it "returns an empty string" do
+        expect(headers.to_s).to eql("")
       end
 
     end

data/spec/lib/http_stub/models/omitted_value_matcher_spec.rb

@@ -10,8 +10,8 @@ describe HttpStub::Models::OmittedValueMatcher  do
 
         let(:actual_value) { nil }
 
-        it "should return true" do
-          perform_match.should be_true
+        it "returns true" do
+          expect(perform_match).to be_truthy
         end
 
       end
@@ -20,8 +20,8 @@ describe HttpStub::Models::OmittedValueMatcher  do
 
         let(:actual_value) { "some non-empty string" }
 
-        it "should return false" do
-          perform_match.should be_false
+        it "returns false" do
+          expect(perform_match).to be_falsey
         end
 
       end
@@ -30,8 +30,8 @@ describe HttpStub::Models::OmittedValueMatcher  do
 
         let(:actual_value) { "" }
 
-        it "should return false" do
-          perform_match.should be_false
+        it "returns false" do
+          expect(perform_match).to be_falsey
         end
 
       end
@@ -43,8 +43,8 @@ describe HttpStub::Models::OmittedValueMatcher  do
       let(:stub_value) { "some other stub value" }
       let(:actual_value) { nil }
 
-      it "should return false" do
-        perform_match.should be_false
+      it "returns false" do
+        expect(perform_match).to be_falsey
       end
 
     end

data/spec/lib/http_stub/models/regexp_value_matcher_spec.rb

@@ -10,8 +10,8 @@ describe HttpStub::Models::RegexpValueMatcher do
 
         let(:actual_value) { "a789$z" }
 
-        it "should return true" do
-          perform_match.should be_true
+        it "returns true" do
+          expect(perform_match).to be_truthy
         end
 
       end
@@ -20,8 +20,8 @@ describe HttpStub::Models::RegexpValueMatcher do
 
         let(:actual_value) { "a789" }
 
-        it "should return false" do
-          perform_match.should be_false
+        it "returns false" do
+          expect(perform_match).to be_falsey
         end
 
       end
@@ -33,8 +33,8 @@ describe HttpStub::Models::RegexpValueMatcher do
       let(:stub_value) { "does not start with regexp:" }
       let(:actual_value) { "some actual value" }
 
-      it "should return false" do
-        perform_match.should be_false
+      it "returns false" do
+        expect(perform_match).to be_falsey
       end
 
     end

data/spec/lib/http_stub/models/registry_spec.rb

@@ -1,15 +1,15 @@
 describe HttpStub::Models::Registry do
 
-  let(:registry) { HttpStub::Models::Registry.new("a_model") }
-
-  let(:logger) { double("Logger").as_null_object }
+  let(:logger)  { double("Logger").as_null_object }
   let(:request) { double("HttpRequest", logger: logger, inspect: "Request inspect result") }
 
+  let(:registry) { HttpStub::Models::Registry.new("a_model") }
+
   describe "#add" do
 
-    it "should log that the model has been registered" do
+    it "logs that the model has been registered" do
       model = double("HttpStub::Models::Model", to_s: "Model as String")
-      logger.should_receive(:info).with(/Model as String/)
+      expect(logger).to receive(:info).with(/Model as String/)
 
       registry.add(model, request)
     end
@@ -24,7 +24,7 @@ describe HttpStub::Models::Registry do
         (1..3).map { |i| double("HttpStub::Models::Model#{i}", :satisfies? => false) }
       end
 
-      before(:each) do
+      before(:example) do
         models.each { |model| registry.add(model, request) }
       end
 
@@ -32,18 +32,18 @@ describe HttpStub::Models::Registry do
 
         let(:matching_model) { models[1] }
 
-        before(:each) { matching_model.stub(:satisfies?).and_return(true) }
+        before(:example) { allow(matching_model).to receive(:satisfies?).and_return(true) }
 
-        it "should return the model" do
-          registry.find_for(request).should eql(matching_model)
+        it "returns the model" do
+          expect(registry.find_for(request)).to eql(matching_model)
         end
 
         describe "and the registry is subsequently cleared" do
 
-          before(:each) { registry.clear(request) }
+          before(:example) { registry.clear(request) }
 
-          it "should return nil" do
-            registry.find_for(request).should be_nil
+          it "returns nil" do
+            expect(registry.find_for(request)).to be_nil
           end
 
         end
@@ -52,20 +52,20 @@ describe HttpStub::Models::Registry do
 
       describe "and multiple registered models satisfy the request" do
 
-        before(:each) do
-          [0, 2].each { |i| models[i].stub(:satisfies?).and_return(true) }
+        before(:example) do
+          [0, 2].each { |i| allow(models[i]).to receive(:satisfies?).and_return(true) }
         end
 
-        it "should support model overrides by returning the last model registered" do
-          registry.find_for(request).should eql(models[2])
+        it "supports model overrides by returning the last model registered" do
+          expect(registry.find_for(request)).to eql(models[2])
         end
 
       end
 
       describe "and no registered models match the request" do
 
-        it "should return nil" do
-          registry.find_for(request).should be_nil
+        it "returns nil" do
+          expect(registry.find_for(request)).to be_nil
         end
 
       end
@@ -74,14 +74,14 @@ describe HttpStub::Models::Registry do
 
     describe "when no model has been registered" do
 
-      it "should return nil" do
-        registry.find_for(request).should be_nil
+      it "returns nil" do
+        expect(registry.find_for(request)).to be_nil
       end
 
     end
 
     it "it should log model discovery diagnostics that includes the complete details of the request" do
-      logger.should_receive(:info).with(/Request inspect result/)
+      expect(logger).to receive(:info).with(/Request inspect result/)
 
       registry.find_for(request)
     end
@@ -96,30 +96,73 @@ describe HttpStub::Models::Registry do
         (1..3).map { |i| double("HttpStub::Models::Model#{i}", :satisfies? => false) }
       end
 
-      before(:each) do
+      before(:example) do
         models.each { |model| registry.add(model, request) }
       end
 
-      it "should return the registered models in the order they were added" do
-        registry.all.should eql(models.reverse)
+      it "returns the registered models in the order they were added" do
+        expect(registry.all).to eql(models.reverse)
       end
 
     end
 
     describe "when no model has been registered" do
 
-      it "should return an empty list" do
-        registry.all.should eql([])
+      it "returns an empty list" do
+        expect(registry.all).to eql([])
+      end
+
+    end
+
+  end
+
+  describe "#copy" do
+
+    class HttpStub::Models::CopyableModel
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def eql?(other)
+        @name = other.name
+      end
+
+    end
+
+    subject { registry.copy }
+
+    context "when multiple models have been registered" do
+
+      let(:models) { (1..3).map { |i| HttpStub::Models::CopyableModel.new("model_#{i}") } }
+
+      before(:each) { models.each { |model| registry.add(model, request) } }
+
+      it "returns a registry containing the models" do
+        result = subject
+
+        expect(result.all).to eql(models)
       end
 
     end
 
+    it "returns a registry that changes independently of the copied registry" do
+      model_to_add = HttpStub::Models::CopyableModel.new("model_to_add")
+
+      result = subject
+
+      registry.add(model_to_add, request)
+      expect(result.all).not_to include(model_to_add)
+    end
+
   end
 
   describe "#clear" do
 
-    it "should log that the models are being cleared" do
-      logger.should_receive(:info).with(/clearing a_model/i)
+    it "logs that the models are being cleared" do
+      expect(logger).to receive(:info).with(/clearing a_model/i)
 
       registry.clear(request)
     end

data/spec/lib/http_stub/models/request_header_parser_spec.rb

@@ -18,8 +18,8 @@ describe HttpStub::Models::RequestHeaderParser do
 
       let(:http_env_elements) { { "HTTP_KEY1" => "value1", "HTTP_KEY2" => "value2", "HTTP_KEY3" => "value3" } }
 
-      it "should return a hash containing only those entries with the prefix removed" do
-        HttpStub::Models::RequestHeaderParser.parse(request).should eql({ "KEY1" => "value1",
+      it "returns a hash containing only those entries with the prefix removed" do
+        expect(HttpStub::Models::RequestHeaderParser.parse(request)).to eql({ "KEY1" => "value1",
                                                                           "KEY2" => "value2",
                                                                           "KEY3" => "value3" })
       end
@@ -30,8 +30,8 @@ describe HttpStub::Models::RequestHeaderParser do
 
       let(:http_env_elements) { {} }
       
-      it "should return an empty hash" do
-        HttpStub::Models::RequestHeaderParser.parse(request).should eql({})
+      it "returns an empty hash" do
+        expect(HttpStub::Models::RequestHeaderParser.parse(request)).to eql({})
       end
       
     end

data/spec/lib/http_stub/models/request_pipeline_spec.rb

@@ -6,8 +6,8 @@ describe HttpStub::Models::RequestPipeline do
 
     let(:response) { double(HttpStub::Models::Response, delay_in_seconds: 5) }
 
-    it "should sleep for specified duration" do
-      request_pipeline.should_receive(:sleep).with(5)
+    it "sleeps for specified duration" do
+      expect(request_pipeline).to receive(:sleep).with(5)
 
       request_pipeline.before_halt(response)
     end

data/spec/lib/http_stub/models/response_spec.rb

@@ -15,12 +15,12 @@ describe HttpStub::Models::Response do
 
     let(:response) { HttpStub::Models::Response::SUCCESS }
 
-    it "should have a status of 200" do
-      response.status.should eql(200)
+    it "has a status of 200" do
+      expect(response.status).to eql(200)
     end
 
-    it "should have a body containing OK to visually indicate success to those interacting via a browser" do
-      response.body.should match(/OK/)
+    it "has a body containing OK to visually indicate success to those interacting via a browser" do
+      expect(response.body).to match(/OK/)
     end
 
   end
@@ -29,12 +29,12 @@ describe HttpStub::Models::Response do
 
     let(:response) { HttpStub::Models::Response::ERROR }
 
-    it "should have a status of 404" do
-      response.status.should eql(404)
+    it "has a status of 404" do
+      expect(response.status).to eql(404)
     end
 
-    it "should have a body containing ERROR to visually indicate the error to those interacting via a browser" do
-      response.body.should match(/ERROR/)
+    it "has a body containing ERROR to visually indicate the error to those interacting via a browser" do
+      expect(response.body).to match(/ERROR/)
     end
 
   end
@@ -45,8 +45,8 @@ describe HttpStub::Models::Response do
 
       context "that is an integer" do
 
-        it "should return the value provided" do
-          response.status.should eql(status)
+        it "returns the value provided" do
+          expect(response.status).to eql(status)
         end
 
       end
@@ -55,8 +55,8 @@ describe HttpStub::Models::Response do
 
         let(:status) { "" }
 
-        it "should return 200" do
-          response.status.should eql(200)
+        it "returns 200" do
+          expect(response.status).to eql(200)
         end
 
       end
@@ -67,8 +67,8 @@ describe HttpStub::Models::Response do
 
       let(:response) { HttpStub::Models::Response.new("body" => body, "delay_in_seconds" => delay_in_seconds) }
 
-      it "should return 200" do
-        response.status.should eql(200)
+      it "returns 200" do
+        expect(response.status).to eql(200)
       end
 
     end
@@ -77,8 +77,8 @@ describe HttpStub::Models::Response do
 
   describe "#body" do
 
-    it "should return the value provided in the arguments" do
-      response.body.should eql("A response body")
+    it "returns the value provided in the arguments" do
+      expect(response.body).to eql("A response body")
     end
 
   end
@@ -89,8 +89,8 @@ describe HttpStub::Models::Response do
 
       context "that is an integer" do
 
-        it "should return the value" do
-          response.delay_in_seconds.should eql(delay_in_seconds)
+        it "returns the value" do
+          expect(response.delay_in_seconds).to eql(delay_in_seconds)
         end
 
       end
@@ -99,8 +99,8 @@ describe HttpStub::Models::Response do
 
         let(:delay_in_seconds) { "" }
 
-        it "should return 0" do
-          response.delay_in_seconds.should eql(0)
+        it "returns 0" do
+          expect(response.delay_in_seconds).to eql(0)
         end
 
       end
@@ -111,8 +111,8 @@ describe HttpStub::Models::Response do
 
       let(:response) { HttpStub::Models::Response.new("status" => status, "body" => body) }
 
-      it "should return 0" do
-        response.delay_in_seconds.should eql(0)
+      it "returns 0" do
+        expect(response.delay_in_seconds).to eql(0)
       end
 
     end
@@ -123,8 +123,8 @@ describe HttpStub::Models::Response do
 
     let(:response_header_hash) { response.headers.to_hash }
 
-    it "should be Headers" do
-      response.headers.should be_a(HttpStub::Models::Headers)
+    it "is Headers" do
+      expect(response.headers).to be_a(HttpStub::Models::Headers)
     end
 
     context "when headers are provided" do
@@ -135,8 +135,8 @@ describe HttpStub::Models::Response do
           { "content-type" => "some/content/type", "some_header" => "some value", "another_header" => "another value" }
         end
 
-        it "should return headers including the provided headers" do
-          response_header_hash.should eql(headers)
+        it "returns headers including the provided headers" do
+          expect(response_header_hash).to eql(headers)
         end
 
       end
@@ -151,12 +151,12 @@ describe HttpStub::Models::Response do
           }
         end
 
-        it "should return headers including the provided headers" do
-          response_header_hash.should include(headers)
+        it "returns headers including the provided headers" do
+          expect(response_header_hash).to include(headers)
         end
 
-        it "should return headers including json as the default response content type" do
-          response_header_hash.should include("content-type" => "application/json")
+        it "returns headers including json as the default response content type" do
+          expect(response_header_hash).to include("content-type" => "application/json")
         end
 
       end
@@ -167,8 +167,8 @@ describe HttpStub::Models::Response do
 
       let(:headers) { nil }
 
-      it "should return headers containing json as the default response content type" do
-        response_header_hash.should eql("content-type" => "application/json")
+      it "returns headers containing json as the default response content type" do
+        expect(response_header_hash).to eql("content-type" => "application/json")
       end
 
     end
@@ -179,24 +179,24 @@ describe HttpStub::Models::Response do
 
     context "when the response is EMPTY" do
 
-      it "should return true" do
-        HttpStub::Models::Response::EMPTY.should be_empty
+      it "returns true" do
+        expect(HttpStub::Models::Response::EMPTY).to be_empty
       end
 
     end
 
     context "when the response is not EMPTY but contains no values" do
 
-      it "should return true" do
-        HttpStub::Models::Response.new.should be_empty
+      it "returns true" do
+        expect(HttpStub::Models::Response.new).to be_empty
       end
 
     end
 
     context "when the response is not EMPTY" do
 
-      it "should return false" do
-        HttpStub::Models::Response::SUCCESS.should_not be_empty
+      it "returns false" do
+        expect(HttpStub::Models::Response::SUCCESS).not_to be_empty
       end
 
     end