http_stub 0.27.0 → 0.28.0.beta1

data/spec/acceptance/stub_match_list_spec.rb

@@ -1,109 +1,73 @@
 describe "Stub match list acceptance" do
-  include_context "configurer integration"
+  include_context "server integration"
 
   describe "GET /http_stub/stubs/matches" do
+    include_context "configurator with stub builder and requester"
 
-    let(:response)          { HTTParty.get("#{server_uri}/http_stub/stubs/matches") }
+    let(:response)          do
+      request_prior_to_match_list_request
+      HTTParty.get("#{server_uri}/http_stub/stubs/matches")
+    end
     let(:response_document) { Nokogiri::HTML(response.body) }
 
-    before(:example) { configure_stub_registrator }
-
     context "when a request has been made matching a stub" do
 
-      before(:example) do
-        stub_registrator.register_stub
-
-        stub_registrator.issue_matching_request
-      end
+      let(:request_prior_to_match_list_request) { stub_requester.issue_matching_request }
 
-      include_context "HTML view including request details"
+      include_context "HTML view including a stub request"
 
       it "returns a response body that contains stub response status" do
-        expect(response.body).to match(/#{escape_html(stub_registrator.stub_response_status)}/)
+        expect(response.body).to match(/#{escape_html(stub_response[:status])}/)
       end
 
       it "returns a response body that contains stub response headers" do
-        stub_registrator.stub_response_headers.each do |expected_header_key, expected_header_value|
+        stub_response[:headers].each do |expected_header_key, expected_header_value|
           expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
         end
       end
 
       it "returns a response body that contains stub response body" do
-        expect(response.body).to match(/#{escape_html(stub_registrator.stub_response_body)}/)
+        expect(response.body).to match(/#{escape_html(stub_response[:body])}/)
       end
 
       it "returns a response body that contains a link to the matched stub" do
         stub_link = response_document.css("a.stub").first
-        expect(stub_registrator.stub_uri).to end_with(stub_link["href"])
+        expect(stub_builder.stub_uri).to end_with(stub_link["href"])
       end
 
-    end
-
-    context "when a request has been made matching a stub whose response includes request references" do
-
-      before(:example) do
-        stub_registrator.with_request_parameters
-        stub_registrator.with_request_interpolation
-
-        stub_registrator.register_stub
+      context "whose response includes request interpolation" do
 
-        stub_registrator.issue_matching_request
-      end
-
-      it "returns a response body that contains stub response status" do
-        expect(response.body).to match(/#{stub_registrator.stub_response_status}/)
-      end
+        before(:example) { stub_builder.with_request_parameters!.and.with_request_interpolation! }
 
-      it "returns a response body that contains stub response headers with interpolated request references" do
-        expected_stub_response_headers = {
-          header_reference:    "request header value 2",
-          parameter_reference: "parameter value 2"
-        }
+        it "returns a response body that contains the matches response status" do
+          expect(response.body).to match(/#{expected_match_response[:status]}/)
+        end
 
-        expected_stub_response_headers.each do |expected_header_key, expected_header_value|
-          expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
+        it "returns a response body that contains the matches response headers with interpolated request references" do
+          expected_match_response[:headers].each do |expected_header_key, expected_header_value|
+            expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
+          end
         end
-      end
 
-      it "returns a response body that contains stub response body with interpolated request references" do
-        expected_stub_response_body = "header: request header value 3, parameter: parameter value 3"
+        it "returns a response body that contains the matches response body with interpolated request references" do
+          expect(response.body).to match(/#{escape_html(expected_match_response[:body])}/)
+        end
 
-        expect(response.body).to match(/#{escape_html(expected_stub_response_body)}/)
-      end
+        it "returns a response body that contains a link to the matched stub" do
+          stub_link = response_document.css("a.stub").first
+          expect(stub_builder.stub_uri).to end_with(stub_link["href"])
+        end
 
-      it "returns a response body that contains a link to the matched stub" do
-        stub_link = response_document.css("a.stub").first
-        expect(stub_registrator.stub_uri).to end_with(stub_link["href"])
       end
 
     end
 
     context "when a request has been made that does not match a stub" do
 
-      before(:example) { stub_registrator.issue_matching_request }
-
-      include_context "HTML view excluding request details"
-
-    end
-
-    context "when a request has been made configuring a stub" do
+      let(:request_prior_to_match_list_request) { stub_requester.issue_non_matching_request }
 
-      before(:example) { stub_registrator.register_stub }
-
-      include_context "HTML view excluding request details"
-
-    end
-
-    context "when a request has been made configuring a scenario" do
-
-      before(:example) { stub_registrator.register_scenario }
-
-      include_context "HTML view excluding request details"
-
-    end
+      include_context "HTML view excluding a stub request"
 
-    def configure_stub_registrator
-      # intentionally blank
     end
 
   end

data/spec/acceptance/stub_miss_list_spec.rb

@@ -1,12 +1,16 @@
 describe "Stub miss list acceptance" do
-  include_context "configurer integration"
+  include_context "server integration"
 
   describe "GET /http_stub/stubs/misses" do
+    include_context "configurator with stub builder and requester"
 
-    let(:response)          { HTTParty.get("#{server_uri}/http_stub/stubs/misses") }
-    let(:response_document) { Nokogiri::HTML(response.body) }
+    let(:request_prior_to_miss_list_request) { nil }
 
-    before(:example) { configure_stub_registrator }
+    let(:response)          do
+      request_prior_to_miss_list_request
+      HTTParty.get("#{server_uri}/http_stub/stubs/misses")
+    end
+    let(:response_document) { Nokogiri::HTML(response.body) }
 
     context "when no miss has been registered" do
 
@@ -16,44 +20,32 @@ describe "Stub miss list acceptance" do
 
     end
 
-    context "when a request has been made that does not match a stub" do
-
-      before(:example) { stub_registrator.issue_matching_request }
-
-      include_context "HTML view including request details"
-
-    end
+    context "when the only request made activates a scenario" do
 
-    context "when a request has been made matching a stub" do
+      let(:configurator) { HttpStub::Examples::ConfiguratorWithTrivialScenarios }
 
-      before(:example) do
-        stub_registrator.register_stub
+      let(:request_prior_to_miss_list_request) { client.activate!("Scenario 1") }
 
-        stub_registrator.issue_matching_request
+      it "returns a response with an empty request list" do
+        expect(response.body).to_not include("Request")
       end
 
-      include_context "HTML view excluding request details"
-
     end
 
-    context "when a request has been made configuring a stub" do
+    context "when a request has been made that does not match a stub" do
 
-      before(:example) { stub_registrator.register_stub }
+      let(:request_prior_to_miss_list_request) { stub_requester.issue_non_matching_request }
 
-      include_context "HTML view excluding request details"
+      include_context "HTML view including a stub request"
 
     end
 
-    context "when a request has been made configuring a scenario" do
-
-      before(:example) { stub_registrator.register_scenario }
+    context "when a request has been made matching a stub" do
 
-      include_context "HTML view excluding request details"
+      let(:request_prior_to_miss_list_request) { stub_requester.issue_matching_request }
 
-    end
+      include_context "HTML view excluding a stub request"
 
-    def configure_stub_registrator
-      # intentionally blank
     end
 
   end

data/spec/acceptance/stub_response_block_spec.rb

@@ -0,0 +1,66 @@
+describe "Stub response block acceptance" do
+  include_context "server integration"
+
+  context "when a server configured with a stub containing a chain of response blocks is started" do
+
+    let(:configurator) { HttpStub::Examples::ConfiguratorWithResponseBlocks }
+
+    context "and a request is made matching the stub" do
+
+      let(:header_value)    { "some header value" }
+      let(:parameter_value) { "some parameter value" }
+
+      let(:response) do
+        HTTParty.get("#{server_uri}/some_path", headers: { "header_name"    => header_value },
+                                                query:   { "parameter_name" => parameter_value })
+      end
+
+      describe "the response status" do
+
+        it "is the value from the last declaring block" do
+          expect(response.code).to eql(201)
+        end
+
+      end
+
+      context "the response headers" do
+
+        it "include headers from early in the chain that are not overridden" do
+          expect(response.headers["header_defaulted"]).to eql("some default header value")
+        end
+
+        it "includes headers from the last declaring block" do
+          expect(response.headers["header_overridden"]).to eql("some overridden header value")
+        end
+
+        it "includes interpolated values from the request headers" do
+          expect(response.headers["header_referencing_header"]).to eql(header_value)
+        end
+
+        it "includes interpolated values from the request parameters" do
+          expect(response.headers["header_referencing_parameter"]).to eql(parameter_value)
+        end
+
+      end
+
+      context "the response body" do
+
+        it "is the value from the last declaring block" do
+          expect(response.body).to_not eql("some default body")
+        end
+
+        it "includes interpolated values from the request headers" do
+          expect(response.body).to include(header_value)
+        end
+
+        it "includes interpolated values from the request headers" do
+          expect(response.body).to include(parameter_value)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/acceptance/stub_spec.rb

@@ -1,297 +1,221 @@
 describe "Stub basics acceptance" do
-  include_context "configurer integration"
+  include_context "server integration"
 
-  context "when a stub is submitted" do
+  let(:configurator) { HttpStub::Examples::ConfiguratorWithTrivialStubs }
 
-    context "that contains no request headers or parameters" do
+  context "when a stub has no match headers or parameters" do
 
-      context "and it contains a response status" do
+    context "and it contains a body only" do
 
-        before(:example) do
-          stub_server.add_stub! do |stub|
-            stub.match_requests(uri: "/stub_with_status", method: :get)
-            stub.respond_with(status: 201, body: "Stub body")
-          end
-        end
-
-        context "and a matching request is made" do
-
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_status") }
-
-          it "responds with the stubbed status" do
-            expect(response.code).to eql(201)
-          end
-
-          it "replays the stubbed body" do
-            expect(response.body).to eql("Stub body")
-          end
-
-        end
-
-        context "and stubs are cleared" do
-
-          before(:example) { stub_server.clear_stubs! }
-
-          context "and a matching request is made" do
-
-            let(:response) { HTTParty.get("#{server_uri}/stub_with_status") }
+      context "and a matching request is made" do
 
-            it "responds with a 404 status code" do
-              expect(response.code).to eql(404)
-            end
-
-          end
+        let(:response) { HTTParty.get("#{server_uri}/stub_with_body_only") }
 
+        it "replays the stubbed body" do
+          expect(response.body).to eql("Stub body")
         end
 
       end
 
-      context "and it does not contain a response status" do
-
-        before(:example) do
-          stub_server.add_stub! do |stub|
-            stub.match_requests(uri: "/stub_without_status", method: :get)
-            stub.respond_with(body: "Stub body")
-          end
-        end
-
-        context "and a matching request is made" do
-
-          let(:response) { HTTParty.get("#{server_uri}/stub_without_status") }
-
-          it "replays the stubbed body" do
-            expect(response.body).to eql("Stub body")
-          end
+    end
 
-        end
+    context "and it contains a response status only" do
 
-      end
+      context "and a matching request is made" do
 
-      context "and it does not contain a request method" do
+        let(:response) { HTTParty.get("#{server_uri}/stub_with_status_only") }
 
-        before(:example) do
-          stub_server.add_stub! { match_requests(uri: "/stub_without_method").respond_with(body: "Stub body") }
+        it "responds with the stubbed status" do
+          expect(response.code).to eql(201)
         end
 
-        context "and a request is made with a matching uri" do
-
-          let(:response) { HTTParty.get("#{server_uri}/stub_without_method") }
-
-          it "replays the stubbed body" do
-            expect(response.body).to eql("Stub body")
-          end
-
+        it "responds with an empty body" do
+          expect(response.body).to eql("")
         end
 
       end
 
     end
 
-    context "that contains request headers" do
+  end
 
-      context "whose values are strings" do
+  context "when a stub has match headers" do
 
-        before(:example) do
-          stub_server.add_stub! do
-            match_requests(uri: "/stub_with_headers", method: :get, headers: { key: "value" })
-            respond_with(status: 202, body: "Another stub body")
-          end
-        end
+    context "whose values are strings" do
 
-        context "and that request is made" do
+      let(:response) do
+        HTTParty.get("#{server_uri}/stub_with_string_match_headers", headers: { "key" => header_value })
+      end
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "value" }) }
+      context "and a matching request is made" do
 
-          it "replays the stubbed response" do
-            expect(response.code).to eql(202)
-            expect(response.body).to eql("Another stub body")
-          end
+        let(:header_value) { "value" }
 
+        it "replays the stubbed response" do
+          expect(response.body).to eql("String match headers body")
         end
 
-        context "and a request with different headers is made" do
+      end
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "other_value" }) }
+      context "and a request with a different header value is made" do
 
-          it "responds with a 404 status code" do
-            expect(response.code).to eql(404)
-          end
+        let(:header_value) { "other_value" }
 
+        it "responds with a 404 status code" do
+          expect(response.code).to eql(404)
         end
 
       end
 
     end
 
-    context "that contains request parameters" do
+  end
 
-      context "whose values are strings" do
+  context "when a stub has match parameters" do
 
-        before(:example) do
-          stub_server.add_stub! do
-            match_requests(uri: "/stub_with_parameters", method: :get, parameters: { key: "value" })
-            respond_with(status: 202, body: "Another stub body")
-          end
-        end
+    context "whose values are strings" do
 
-        context "and that request is made" do
+      let(:response) { HTTParty.get("#{server_uri}/stub_with_string_match_parameters?key=#{parameter_value}") }
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=value") }
+      context "and a matching request is made" do
 
-          it "replays the stubbed response" do
-            expect(response.code).to eql(202)
-            expect(response.body).to eql("Another stub body")
-          end
+        let(:parameter_value) { "value" }
 
+        it "replays the stubbed response" do
+          expect(response.body).to eql("String match parameters body")
         end
 
-        context "and a request with different parameters is made" do
+      end
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=another_value") }
+      context "and a request with different parameters is made" do
 
-          it "responds with a 404 status code" do
-            expect(response.code).to eql(404)
-          end
+        let(:parameter_value) { "another_value" }
 
+        it "responds with a 404 status code" do
+          expect(response.code).to eql(404)
         end
 
       end
 
-      context "whose values are numbers" do
+    end
 
-        before(:example) do
-          stub_server.add_stub! do
-            match_requests(uri: "/stub_with_parameters", method: :get, parameters: { key: 88 })
-            respond_with(status: 203, body: "Body for parameter number")
-          end
-        end
+    context "whose values are numerics" do
 
-        context "and that request is made" do
+      let(:response) { HTTParty.get("#{server_uri}/stub_with_numeric_match_parameters?key=#{parameter_value}") }
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=88") }
+      context "and a matching request is made" do
 
-          it "replays the stubbed response" do
-            expect(response.code).to eql(203)
-            expect(response.body).to eql("Body for parameter number")
-          end
+        let(:parameter_value) { 88 }
 
+        it "replays the stubbed response" do
+          expect(response.body).to eql("Numeric match parameters body")
         end
 
       end
 
     end
 
-    describe "that contains response headers" do
+  end
 
-      context "with a content-type header" do
+  describe "when a stub has response headers" do
 
-        before(:example) do
-          stub_server.add_stub! do
-            match_requests(uri: "/some_stub_path", method: :get)
-            respond_with(body: "Some stub body", headers: { "content-type" => "application/xhtml" })
-          end
-        end
+    context "including a content-type header" do
 
-        it "registers the stub" do
-          response = HTTParty.get("#{server_uri}/some_stub_path")
+      context "and a matching request is made" do
 
+        let(:response) { HTTParty.get("#{server_uri}/stub_with_content_type_header") }
+
+        it "responds with the header" do
           expect(response.content_type).to eql("application/xhtml")
         end
 
       end
 
-      context "which are custom" do
-
-        describe "and an attempt is made to register a response with a other headers" do
+    end
 
-          let(:response_headers) do
-            {
-              "some_header" => "some value",
-              "another_header" => "another value",
-              "yet_another_header" => "yet another value"
-            }
-          end
+    context "that are custom" do
 
-          before(:example) do
-            stub_server.add_stub! do |stub|
-              stub.match_requests(uri: "/some_stub_path", method: :get)
-              stub.respond_with(body: "Some stub body", headers: response_headers)
-            end
-          end
+      context "and a matching request is made" do
 
-          it "registers the stub" do
-            response = Net::HTTP.get_response("localhost", "/some_stub_path", 8001)
+        let(:expected_response_headers) do
+          {
+            "some_header"        => "some value",
+            "another_header"     => "another value",
+            "yet_another_header" => "yet another value"
+          }
+        end
 
-            response_headers.each { |key, value| expect(response[key]).to eql(value) }
-          end
+        let(:response) { HTTParty.get("#{server_uri}/stub_with_response_headers") }
 
+        it "responds with the headers" do
+          expected_response_headers.each { |key, value| expect(response.headers[key]).to eql(value) }
         end
 
       end
 
     end
 
-    context "that contains a response body that is a file" do
+  end
 
-      let(:configurer_specification) { { class: HttpStub::Examples::ConfigurerWithFileResponses } }
+  context "when a stub has a response body that is a file" do
 
-      context "and a request that matches is made" do
+    let(:configurator) { HttpStub::Examples::ConfiguratorWithFileResponses }
 
-        context "matching a stub with a custom content-type" do
+    context "and a request that matches is made" do
 
-          let(:response) { issue_request }
+      context "matching a stub with a custom content-type" do
 
-          it "responds with a status code of 200" do
-            expect(response.code).to eql(200)
-          end
+        let(:response) { issue_request }
 
-          it "responds with the configured content type" do
-            expect(response.content_type).to eql("application/pdf")
-          end
-
-          it "responds with the configured file" do
-            expect(response).to contain_file(HttpStub::Examples::ConfigurerWithFileResponses::FILE_PATH)
-          end
+        it "responds with a status code of 200" do
+          expect(response.code).to eql(200)
+        end
 
-          context "and a subsequent request is made that requests the file if it has been modified" do
+        it "responds with the configured content type" do
+          expect(response.content_type).to eql("application/pdf")
+        end
 
-            let(:first_response)          { issue_request }
-            let(:file_last_modified_time) { first_response.headers["Last-Modified"] }
+        it "responds with the configured file" do
+          expect(response).to contain_file(HttpStub::Examples::ConfiguratorWithFileResponses::FILE_PATH)
+        end
 
-            let(:second_response) { issue_request("if_modified_since" => file_last_modified_time) }
+        context "and a subsequent request is made that requests the file if it has been modified" do
 
-            it "responds with a status code of 304 to indicate the file is unchanged" do
-              expect(second_response.code).to eql(304)
-            end
+          let(:first_response)          { issue_request }
+          let(:file_last_modified_time) { first_response.headers["Last-Modified"] }
 
-            it "responds with no content type" do
-              expect(second_response.content_type).to be(nil)
-            end
+          let(:second_response) { issue_request("if_modified_since" => file_last_modified_time) }
 
-            it "responds with an empty body" do
-              expect(second_response.body).to be(nil)
-            end
+          it "responds with a status code of 304 to indicate the file is unchanged" do
+            expect(second_response.code).to eql(304)
+          end
 
+          it "responds with no content type" do
+            expect(second_response.content_type).to be(nil)
           end
 
-          def issue_request(headers={})
-            HTTParty.get("#{server_uri}/stub_response_with_file", headers: headers)
+          it "responds with an empty body" do
+            expect(second_response.body).to be(nil)
           end
 
         end
 
-        context "matching a stub with no content-type" do
+        def issue_request(headers={})
+          HTTParty.get("#{server_uri}/stub_response_with_file", headers: headers)
+        end
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_response_with_file_and_no_content_type") }
+      end
 
-          it "responds with a default content type of 'application/octet-stream'" do
-            expect(response.content_type).to eql("application/octet-stream")
-          end
+      context "matching a stub with no content-type" do
 
-          it "responds with the configured response" do
-            expect(response).to contain_file(HttpStub::Examples::ConfigurerWithFileResponses::FILE_PATH)
-          end
+        let(:response) { HTTParty.get("#{server_uri}/stub_response_with_file_and_no_content_type") }
+
+        it "responds with a default content type of 'application/octet-stream'" do
+          expect(response.content_type).to eql("application/octet-stream")
+        end
 
+        it "responds with the configured response" do
+          expect(response).to contain_file(HttpStub::Examples::ConfiguratorWithFileResponses::FILE_PATH)
         end
 
       end