http_stub 0.27.0 → 0.28.0.beta1

data/spec/acceptance/stub_control_values_spec.rb

@@ -1,32 +1,53 @@
 describe "Stub control value acceptance" do
-  include_context "configurer integration"
+  include_context "server integration"
 
-  let(:configurer_specification) { { class: HttpStub::Examples::ConfigurerWithTrivialStub } }
+  let(:configurator) { HttpStub::Examples::ConfiguratorWithStubControlValues }
 
-  context "when a stub is submitted" do
+  context "when a stub match uri has regular expression containing meta characters" do
 
-    context "with a stub uri that is regular expression containing meta characters" do
+    context "and a request is made whose uri matches the regular expression" do
 
-      before(:example) do
-        stub_server.add_stub! do |stub|
-          stub.match_requests(uri: /\/stub\/regexp\/\$key=value/, method: :get)
-          stub.respond_with(body: "Stub body")
-        end
+      let(:response) { HTTParty.get("#{server_uri}/match/stub/regexp/$key=value") }
+
+      it "replays the stubbed body" do
+        expect(response.body).to eql("Regular expression uri stub body")
+      end
+
+    end
+
+    context "and a request is made whose uri does not match the regular expression" do
+
+      let(:response) { HTTParty.get("#{server_uri}/stub/no_match/regexp") }
+
+      it "responds with a 404 status code" do
+        expect(response.code).to eql(404)
       end
 
-      context "and a request is made whose uri matches the regular expression" do
+    end
+
+  end
+
+  context "when stub match headers" do
 
-        let(:response) { HTTParty.get("#{server_uri}/match/stub/regexp/$key=value") }
+    context "have regular expression values" do
 
-        it "replays the stubbed body" do
-          expect(response.body).to eql("Stub body")
+      let(:response) do
+        HTTParty.get("#{server_uri}/stub_with_regular_expression_headers", headers: { "key" => header_value })
+      end
+
+      context "and a request that matches is made" do
+
+        let(:header_value) { "matching_value" }
+
+        it "replays the stubbed response" do
+          expect(response.body).to eql("Regular expression headers stub body")
         end
 
       end
 
-      context "and a request is made whose uri does not match the regular expression" do
+      context "and a request that does not match is made" do
 
-        let(:response) { HTTParty.get("#{server_uri}/stub/no_match/regexp") }
+        let(:header_value) { "does_not_match_value" }
 
         it "responds with a 404 status code" do
           expect(response.code).to eql(404)
@@ -36,33 +57,22 @@ describe "Stub control value acceptance" do
 
     end
 
-    context "with headers whose values are regular expressions" do
-
-      before(:example) do
-        stub_server.add_stub! do |stub|
-          stub.match_requests(uri: "/stub_with_headers", method: :get, headers: { key: /^match.*/ })
-          stub.respond_with(status: 202, body: "Another stub body")
-        end
-      end
+    context "have values indicating they must be omitted" do
 
       context "and a request that matches is made" do
 
-        let(:response) do
-          HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "matching_value" })
-        end
+        let(:response) { HTTParty.get("#{server_uri}/stub_with_omitted_headers") }
 
         it "replays the stubbed response" do
-          expect(response.code).to eql(202)
-          expect(response.body).to eql("Another stub body")
+          expect(response.body).to eql("Omitted headers stub body")
         end
 
       end
 
       context "and a request that does not match is made" do
 
-        let(:response) do
-          HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "does_not_match_value" })
-        end
+        let(:headers)  { { "key" => "must_be_omitted" } }
+        let(:response) { HTTParty.get("#{server_uri}/stub_with_omitted_headers", headers: headers) }
 
         it "responds with a 404 status code" do
           expect(response.code).to eql(404)
@@ -72,91 +82,73 @@ describe "Stub control value acceptance" do
 
     end
 
-    context "with parameters" do
+  end
 
-      context "whose values are regular expressions" do
+  context "when stub match parameters" do
 
-        before(:example) do
-          stub_server.add_stub! do |stub|
-            stub.match_requests(uri: "/stub_with_parameters", method: :get, parameters: { key: /^match.*/ })
-            stub.respond_with(status: 202, body: "Another stub body")
-          end
-        end
+    context "have regular expression values" do
 
-        context "and a request that matches is made" do
+      let(:response) do
+        HTTParty.get("#{server_uri}/stub_with_regular_expression_parameters", query: { "key" => parameter_value })
+      end
 
-          let(:parameters) { { "key" => "matching_value" } }
-          let(:response)   { HTTParty.get("#{server_uri}/stub_with_parameters", query: parameters) }
+      context "and a request that matches 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) { "matching_value" }
 
+        it "replays the stubbed response" do
+          expect(response.body).to eql("Regular expression parameters stub body")
         end
 
-        context "and a request that does not match is made" do
+      end
 
-          let(:parameters) { { "key" => "does_not_match_value" } }
-          let(:response)   { HTTParty.get("#{server_uri}/stub_with_parameters", query: parameters) }
+      context "and a request that does not match is made" do
 
-          it "responds with a 404 status code" do
-            expect(response.code).to eql(404)
-          end
+        let(:parameter_value) { "does_not_match_value" }
 
+        it "responds with a 404 status code" do
+          expect(response.code).to eql(404)
         end
 
       end
 
-      context "whose values indicate the parameters must be omitted" do
-
-        before(:example) do
-          stub_server.add_stub! do |stub|
-            stub.match_requests(uri: "/stub_with_omitted_parameters", method: :get, parameters: { key: :omitted })
-            stub.respond_with(status: 202, body: "Omitted parameter stub body")
-          end
-        end
+    end
 
-        context "and a request that matches is made" do
+    context "have values indicating they must be omitted" do
 
-          let(:response) { HTTParty.get("#{server_uri}/stub_with_omitted_parameters") }
+      context "and a request that matches is made" do
 
-          it "replays the stubbed response" do
-            expect(response.code).to eql(202)
-            expect(response.body).to eql("Omitted parameter stub body")
-          end
+        let(:response) { HTTParty.get("#{server_uri}/stub_with_omitted_parameters") }
 
+        it "replays the stubbed response" do
+          expect(response.body).to eql("Omitted parameters stub body")
         end
 
-        context "and a request that does not match is made" do
+      end
 
-          let(:parameters) { { "key" => "must_be_omitted" } }
-          let(:response)   { HTTParty.get("#{server_uri}/stub_with_omitted_parameters", query: parameters) }
+      context "and a request that does not match is made" do
 
-          it "responds with a 404 status code" do
-            expect(response.code).to eql(404)
-          end
+        let(:parameters) { { "key" => "must_be_omitted" } }
+        let(:response)   { HTTParty.get("#{server_uri}/stub_with_omitted_parameters", query: parameters) }
 
+        it "responds with a 404 status code" do
+          expect(response.code).to eql(404)
         end
 
       end
 
     end
 
-    context "with a response delay" do
-
-      before(:example) do
-        stub_server.add_stub! { match_requests(uri: "/some_stub_path", method: :get).respond_with(delay_in_seconds: 1) }
-      end
+  end
 
-      it "delays the response by the time provided" do
-        start_time = Time.now
+  context "when stub has a response delay" do
 
-        response = HTTParty.get("#{server_uri}/some_stub_path")
+    it "delays the response by the time provided" do
+      start_time = Time.now
 
-        expect(Time.now - start_time).to be >= 1.0
-      end
+      HTTParty.get("#{server_uri}/stub_with_response_delay")
 
+      expect(Time.now - start_time).to be >= 1.0
     end
 
   end

data/spec/acceptance/stub_match_last_spec.rb

@@ -1,114 +1,107 @@
 describe "Stub matches last acceptance" do
-  include_context "configurer integration"
+  include_context "server integration"
 
   describe "GET /http_stub/stubs/matches/last" do
+    include_context "configurator with stub builder and requester"
 
-    let(:request_uri)        { stub_registrator.request_uri }
-    let(:request_method)     { stub_registrator.request_method }
-    let(:request_parameters) { { uri: request_uri, method: request_method } }
-    let(:response)           { HTTParty.get("#{server_uri}/http_stub/stubs/matches/last", query: request_parameters) }
-    let(:json_response)      { JSON.parse(response.body) }
-
-    before(:example) { configure_stub_registrator }
-
-    context "when a request has been made matching a stub" do
+    let(:request_prior_to_last_match_request) { stub_requester.issue_matching_request}
+    let(:ensure_stub_request_is_issued)       { request_prior_to_last_match_request }
 
-      before(:example) do
-        stub_registrator.register_stub
+    let(:request_parameters) { { uri: stub_match_rules[:uri], method: stub_match_rules[:method] } }
+    let(:last_match_request) { HTTParty.get("#{server_uri}/http_stub/stubs/matches/last", query: request_parameters) }
+    let(:response)           do
+      request_prior_to_last_match_request
+      last_match_request
+    end
+    let(:json_response)      { JSON.parse(response.body) }
 
-        stub_registrator.issue_matching_request
-      end
+    context "when a request has been made matching a stub against request headers" do
 
       it "returns a 200 response" do
         expect(response.code).to eql(200)
       end
 
-      it "returns JSON containing the requests uri" do
-        expect_match_request_to_include("uri" => request_uri)
+      it "returns JSON containing the matching requests uri" do
+        expect_match_request_to_include("uri" => stub_match_rules[:uri])
       end
 
-      it "returns JSON containing the requests method" do
-        expect_match_request_to_include("method" => request_method)
+      it "returns JSON containing the matching requests method" do
+        expect_match_request_to_include("method" => stub_match_rules[:method])
       end
 
-      it "returns JSON containing the requests headers whose names are in uppercase" do
-        stub_registrator.request_headers.each do |header_key, expected_header_value|
+      it "returns JSON containing the matching requests headers whose names are in uppercase" do
+        stub_match_rules[:headers].each do |header_key, expected_header_value|
           expect_match_request_to_include("headers" => hash_including(header_key.upcase => expected_header_value))
         end
       end
 
-      context "when the request contains parameters" do
-
-        def configure_stub_registrator
-          stub_registrator.with_request_parameters
-        end
-
-        it "returns JSON containing the requests parameters" do
-          stub_registrator.request_parameters.each do |expected_parameter_key, expected_parameter_value|
-            expect_match_request_to_include(
-              "parameters" => hash_including(expected_parameter_key => expected_parameter_value)
-            )
-          end
-        end
-
-      end
-
-      context "when the request contains a body" do
-
-        def configure_stub_registrator
-          stub_registrator.with_request_body
-        end
-
-        it "returns JSON containing the requests body" do
-          expect_match_request_to_include("body" => stub_registrator.request_body)
-        end
-
-      end
-
       it "returns JSON containing the matches response status" do
-        expect_match_response_to_include("status" => stub_registrator.stub_response_status)
+        expect_match_response_to_include("status" => expected_match_response[:status])
       end
 
       it "returns JSON containing the matches response headers" do
-        stub_registrator.stub_response_headers.each do |expected_header_key, expected_header_value|
+        expected_match_response[:headers].each do |expected_header_key, expected_header_value|
           expect_match_response_to_include("headers" => hash_including(expected_header_key => expected_header_value))
         end
       end
 
       it "returns JSON containing the matches response body" do
-        expect_match_response_to_include("body" => stub_registrator.stub_response_body)
+        expect_match_response_to_include("body" => expected_match_response[:body])
       end
 
       it "returns JSON containing the uri of the matched stub" do
-        expect_match_stub_to_include("uri" => stub_registrator.stub_uri)
+        expect_match_stub_to_include("uri" => stub_builder.stub_uri)
       end
 
       it "returns JSON containing the request match rules of the matched stub" do
-        expect_match_stub_to_include("match_rules" => hash_including("uri" => stub_registrator.request_uri))
+        expect_match_stub_to_include("match_rules" => hash_including("uri" => stub_match_rules[:uri]))
       end
 
       it "returns JSON containing the configured response of the matched stub" do
-        expect_match_stub_to_include("response" => hash_including("status" => stub_registrator.stub_response_status))
+        expect_match_stub_to_include("response" => hash_including("status" => stub_response[:status]))
       end
 
     end
 
-    context "when a request has been made matching a stub whose response includes request references" do
+    context "when a request has been made matching a stub against request parameters" do
+
+      before(:example) { stub_builder.with_request_parameters! }
 
-      before(:example) do
-        stub_registrator.with_request_parameters
-        stub_registrator.with_request_interpolation
+      it "returns JSON containing the requests parameters" do
+        ensure_stub_request_is_issued
 
-        stub_registrator.register_stub
+        stub_request[:parameters].each do |expected_parameter_key, expected_parameter_value|
+          expect_match_request_to_include(
+            "parameters" => hash_including(expected_parameter_key => expected_parameter_value)
+          )
+        end
+      end
+
+    end
+    
+    context "when a request has been made matching a stub against a body" do
+
+      it "returns JSON containing the requests body" do
+        ensure_stub_request_is_issued
 
-        stub_registrator.issue_matching_request
+        expect_match_request_to_include("body" => stub_request[:body])
       end
 
+    end
+
+    context "when a request has been made matching a stub whose response includes request interpolation" do
+
+      before(:example) { stub_builder.with_request_parameters!.and.with_request_interpolation! }
+
       it "returns a 200 response" do
         expect(response.code).to eql(200)
       end
 
-      it "returns JSON containing the matches response headers with interpolated request references" do
+      it "returns JSON containing the response block source code of the matched stub" do
+        expect_match_stub_to_include("response" => hash_including("blocks" => [ stub_response[:block].source ]))
+      end
+
+      it "returns JSON containing the matches response headers with interpolated request values" do
         expected_stub_response_headers = {
           "header_reference"    => "request header value 2",
           "parameter_reference" => "parameter value 2"
@@ -119,7 +112,7 @@ describe "Stub matches last acceptance" do
         end
       end
 
-      it "returns JSON containing the matches response body with interpolated request references" do
+      it "returns JSON containing the matches response body with interpolated request values" do
         expected_stub_response_body = "header: request header value 3, parameter: parameter value 3"
 
         expect_match_response_to_include("body" => expected_stub_response_body)
@@ -129,7 +122,7 @@ describe "Stub matches last acceptance" do
 
     context "when a request has been made that does not match a stub" do
 
-      before(:example) { stub_registrator.issue_matching_request }
+      let(:request_prior_to_last_match_request) { stub_requester.issue_non_matching_request }
 
       it "returns a 404 response" do
         expect(response.code).to eql(404)
@@ -137,9 +130,9 @@ describe "Stub matches last acceptance" do
 
     end
 
-    context "when a request has been made configuring a stub" do
+    context "when no request has been made" do
 
-      before(:example) { stub_registrator.register_stub }
+      let(:request_prior_to_last_match_request) { nil }
 
       it "returns a 404 response" do
         expect(response.code).to eql(404)
@@ -147,20 +140,6 @@ describe "Stub matches last acceptance" do
 
     end
 
-    context "when a request has been made configuring a scenario" do
-
-      before(:example) { stub_registrator.register_scenario }
-
-      it "returns a 404 response" do
-        expect(response.code).to eql(404)
-      end
-
-    end
-
-    def configure_stub_registrator
-      # intentionally blank
-    end
-
     def expect_match_request_to_include(hash)
       expect(json_response).to(include("request" => hash_including(hash)))
     end
@@ -170,7 +149,8 @@ describe "Stub matches last acceptance" do
     end
 
     def expect_match_stub_to_include(hash)
-      expect(json_response).to(include("stub" => hash_including(hash)))
+      response_hash = json_response
+      expect(response_hash).to(include("stub" => hash_including(hash)))
     end
 
   end