http_stub 0.15.5 → 0.16.0.pre1

data/spec/acceptance/configurer_initialization_spec.rb

@@ -0,0 +1,158 @@
+describe "Configurer initialization acceptance" do
+  include_context "configurer integration"
+
+  let(:configurer) { HttpStub::Examples::ConfigurerWithComplexInitializer.new }
+
+  context "when a configurer is initialized" do
+
+    before(:example) { configurer.class.initialize! }
+
+    context "that contains a class stub" do
+
+      let(:configurer) { HttpStub::Examples::ConfigurerWithStub.new }
+
+      it "registers the stub" do
+        response = HTTParty.get("#{server_uri}/a_class_stub")
+
+        expect(response.code).to eql(201)
+        expect(response.body).to eql("Class stub body")
+      end
+
+      context "and the stub is overridden" do
+
+        before(:example) do
+          configurer.stub_response!("/a_class_stub", method: :get, response: { body: "Other class stub body" })
+        end
+
+        context "and the configurer is re-initialized" do
+
+          before(:example) do
+            configurer.class.initialize!
+          end
+
+          it "re-establishes the class stub as having priority" do
+            response = HTTParty.get("#{server_uri}/a_class_stub")
+
+            expect(response.code).to eql(201)
+            expect(response.body).to eql("Class stub body")
+          end
+
+        end
+
+      end
+
+    end
+
+    context "and the initializer contains conventional stubs" do
+
+      let(:configurer) { HttpStub::Examples::ConfigurerWithComplexInitializer.new }
+
+      it "registers the stub" do
+        response = HTTParty.get("#{server_uri}/stubbed_during_initialization_path")
+
+        expect(response.code).to eql(200)
+        expect(response.body).to eql("Stubbed during initialization body")
+      end
+
+      context "and another stub is registered" do
+
+        before(:example) do
+          configurer.stub_response!("/another_stub", method: :get, response: { body: "Another stub body" })
+        end
+
+        context "and the servers remembered stubs are recalled" do
+
+          before(:example) { configurer.recall_stubs! }
+
+          it "removes the stub registered post-initialization" do
+            response = HTTParty.get("#{server_uri}/another_stub")
+
+            expect(response.code).to eql(404)
+          end
+
+          it "retains the stub registered during initialization" do
+            response = HTTParty.get("#{server_uri}/stubbed_during_initialization_path")
+
+            expect(response.code).to eql(200)
+            expect(response.body).to eql("Stubbed during initialization body")
+          end
+
+        end
+
+      end
+
+    end
+
+    context "and the configurer contains an on initialize callback" do
+
+      let(:configurer) { HttpStub::Examples::ConfigurerWithInitializeCallback.new }
+
+      it "executes the callback" do
+        response = HTTParty.get("#{server_uri}/stubbed_on_initialize_path")
+
+        expect(response.code).to eql(200)
+        expect(response.body).to eql("Stubbed on initialize body")
+      end
+
+    end
+
+  end
+
+  context "when a configurer is uninitialized" do
+
+    context "and the configurer is informed that the server has started" do
+
+      before(:example) { configurer.server_has_started! }
+
+      it "does not initialize the configurer" do
+        activation_lambda = lambda { configurer.activate!("an_activator") }
+
+        expect(activation_lambda).to raise_error(/error occurred activating 'an_activator'/i)
+      end
+
+      context "and an attempt is made to register a stub" do
+
+        before(:example) do
+          configurer.stub_response!("/some_stub_path", method: :get, response: { body: "Some stub body" })
+        end
+
+        it "registers the stub" do
+          response = HTTParty.get("#{server_uri}/some_stub_path")
+
+          expect(response.code).to eql(200)
+          expect(response.body).to eql("Some stub body")
+        end
+
+      end
+
+    end
+
+    context "and the configurer has not been informed that the server has started" do
+
+      context "and an attempt is made to activate a stub" do
+
+        it "raises an exception indicating an error occurred during activation" do
+          activation_lambda = lambda { configurer.activate!("an_activator") }
+
+          expect(activation_lambda).to raise_error(/error occurred activating 'an_activator'/i)
+        end
+
+      end
+
+    end
+
+    context "and the configurer contains an on initialize callback" do
+
+      let(:configurer) { HttpStub::Examples::ConfigurerWithInitializeCallback.new }
+
+      it "does not execute the callback" do
+        response = HTTParty.get("#{server_uri}/stubbed_on_initialize_path")
+
+        expect(response.code).to eql(404)
+      end
+
+    end
+
+  end
+
+end

data/spec/acceptance/scenario_spec.rb

@@ -0,0 +1,91 @@
+describe "Scenario acceptance" do
+  include_context "configurer integration"
+
+  context "when a configurer that contains scenario's is initialized" do
+
+    let(:configurer)  { HttpStub::Examples::ConfigurerWithTrivialScenarios.new }
+
+    before(:example) { configurer.class.initialize! }
+
+    context "and a scenario is activated" do
+
+      context "containing stubs" do
+
+        before(:example) { configurer.activate!("scenario_1") }
+
+        (1..3).each do |stub_number|
+
+          context "and scenario stub request ##{stub_number} is made" do
+
+            let(:response) { HTTParty.get("#{server_uri}/scenario_stub_path_#{stub_number}") }
+
+            it "replays the stubbed response" do
+              expect(response.code).to eql(200 + stub_number)
+              expect(response.body).to eql("Scenario stub #{stub_number} body")
+            end
+
+          end
+
+        end
+
+      end
+
+      context "containing triggered scenarios" do
+
+        before(:example) { configurer.activate!("scenario_activating_another_scenario") }
+
+        (1..3).each do |stub_number|
+
+          context "and a request is made matching stub ##{stub_number} within the triggered scenario" do
+
+            let(:response) { HTTParty.get("#{server_uri}/scenario_stub_path_#{stub_number}") }
+
+            it "triggers all related scenarios" do
+              expect(response.code).to eql(200 + stub_number)
+              expect(response.body).to eql("Scenario stub #{stub_number} body")
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+    context "and the scenario is not activated" do
+
+      context "and a scenario stub request is made" do
+
+        let(:response) { HTTParty.get("#{server_uri}/scenario_stub_path_1") }
+
+        it "responds with a 404 status code" do
+          expect(response.code).to eql(404)
+        end
+
+      end
+
+    end
+
+    context "and the response contains a file" do
+
+      let(:configurer) { HttpStub::Examples::ConfigurerWithFileResponses.new }
+
+      before(:example) { configurer.activate!("scenario_with_file") }
+
+      context "and the stub request is made" do
+
+        let(:response) { HTTParty.get("#{server_uri}/activated_response_with_file") }
+
+        it "replays the stubbed response" do
+          expect(response.code).to eql(200)
+          expect_response_to_contain_file(HttpStub::Examples::ConfigurerWithFileResponses::FILE_PATH)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/acceptance/stub_control_values_spec.rb

@@ -0,0 +1,160 @@
+describe "Stub control value acceptance" do
+  include_context "configurer integration"
+
+  let(:configurer)  { HttpStub::Examples::ConfigurerWithStub.new }
+
+  before(:example) { configurer.class.initialize! }
+
+  context "when a stub is submitted" do
+
+    context "with a stub uri that is regular expression containing meta characters" do
+
+      before(:example) do
+        configurer.stub_response!(/\/stub\/regexp\/\$key=value/, method: :get, response: { body: "Stub body" })
+      end
+
+      context "and a request is made whose uri matches the regular expression" do
+
+        let(:response) { HTTParty.get("#{server_uri}/match/stub/regexp/$key=value") }
+
+        it "replays the stubbed body" do
+          expect(response.body).to eql("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
+
+      end
+
+    end
+
+    context "with headers whose values are regular expressions" do
+
+      before(:example) do
+        configurer.stub_response!(
+          "/stub_with_headers", method: :get, headers: { key: /^match.*/ },
+          response: { status: 202, body: "Another stub body" }
+        )
+      end
+
+      context "and a request that matches is made" do
+
+        let(:response) do
+          HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "matching_value" })
+        end
+
+        it "replays the stubbed response" do
+          expect(response.code).to eql(202)
+          expect(response.body).to eql("Another 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
+
+        it "responds with a 404 status code" do
+          expect(response.code).to eql(404)
+        end
+
+      end
+
+    end
+
+    context "with parameters" do
+
+      context "whose values are regular expressions" do
+
+        before(:example) do
+          configurer.stub_response!(
+            "/stub_with_parameters", method: :get, parameters: { key: /^match.*/ },
+            response: { status: 202, body: "Another stub body" }
+          )
+        end
+
+        context "and a request that matches is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=matching_value") }
+
+          it "replays the stubbed response" do
+            expect(response.code).to eql(202)
+            expect(response.body).to eql("Another stub body")
+          end
+
+        end
+
+        context "and a request that does not match is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=does_not_match_value") }
+
+          it "responds with a 404 status code" do
+            expect(response.code).to eql(404)
+          end
+
+        end
+
+      end
+
+      context "whose values indicate the parameters must be omitted" do
+
+        before(:example) do
+          configurer.stub_response!(
+            "/stub_with_omitted_parameters", method: :get, parameters: { key: :omitted },
+            response: { status: 202, body: "Omitted parameter stub body" }
+          )
+        end
+
+        context "and a request that matches is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_omitted_parameters") }
+
+          it "replays the stubbed response" do
+            expect(response.code).to eql(202)
+            expect(response.body).to eql("Omitted parameter stub body")
+          end
+
+        end
+
+        context "and a request that does not match is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_omitted_parameters?key=must_be_omitted") }
+
+          it "responds with a 404 status code" do
+            expect(response.code).to eql(404)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "with a response delay" do
+
+      before(:example) do
+        configurer.stub_response!("/some_stub_path", method: :get, response: { delay_in_seconds: 2 })
+      end
+
+      it "delays to response by the time provided" do
+        start_time = Time.now
+
+        response = HTTParty.get("#{server_uri}/some_stub_path")
+
+        expect(Time.now - start_time).to be >= 2.0
+      end
+
+    end
+
+  end
+
+end

data/spec/acceptance/stub_spec.rb

@@ -0,0 +1,290 @@
+describe "Stub basics acceptance" do
+  include_context "configurer integration"
+
+  let(:configurer)  { HttpStub::Examples::ConfigurerWithStub.new }
+
+  before(:example) { configurer.class.initialize! }
+
+  context "when a stub is submitted" do
+
+    context "that contains no request headers or parameters" do
+
+      context "and it contains a response status" do
+
+        before(:example) do
+          stub_server.add_stub! do
+            match_requests("/stub_with_status", method: :get).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) { configurer.clear_stubs! }
+
+          context "and a matching request is made" do
+
+            let(:response) { HTTParty.get("#{server_uri}/stub_with_status") }
+
+            it "responds with a 404 status code" do
+              expect(response.code).to eql(404)
+            end
+
+          end
+
+        end
+
+      end
+
+      context "and it does not contain a response status" do
+
+        before(:example) do
+          stub_server.add_stub! { match_requests("/stub_without_status", method: :get).respond_with(body: "Stub body") }
+        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 does not contain a request method" do
+
+        before(:example) do
+          stub_server.add_stub! { match_requests("/stub_without_method").respond_with(body: "Stub body") }
+        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
+
+        end
+
+      end
+
+    end
+
+    context "that contains request headers" do
+
+      context "whose values are strings" do
+
+        before(:example) do
+          stub_server.add_stub! do
+            match_requests("/stub_with_headers", method: :get, headers: { key: "value" })
+            respond_with(status: 202, body: "Another stub body")
+          end
+        end
+
+        context "and that request is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "value" }) }
+
+          it "replays the stubbed response" do
+            expect(response.code).to eql(202)
+            expect(response.body).to eql("Another stub body")
+          end
+
+        end
+
+        context "and a request with different headers is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_headers", headers: { "key" => "other_value" }) }
+
+          it "responds with a 404 status code" do
+            expect(response.code).to eql(404)
+          end
+
+        end
+
+      end
+
+    end
+
+    context "that contains request parameters" do
+
+      context "whose values are strings" do
+
+        before(:example) do
+          stub_server.add_stub! do
+            match_requests("/stub_with_parameters", method: :get, parameters: { key: "value" })
+            respond_with(status: 202, body: "Another stub body")
+          end
+        end
+
+        context "and that request is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=value") }
+
+          it "replays the stubbed response" do
+            expect(response.code).to eql(202)
+            expect(response.body).to eql("Another stub body")
+          end
+
+        end
+
+        context "and a request with different parameters is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=another_value") }
+
+          it "responds with a 404 status code" do
+            expect(response.code).to eql(404)
+          end
+
+        end
+
+      end
+
+      context "whose values are numbers" do
+
+        before(:example) do
+          stub_server.add_stub! do
+            match_requests("/stub_with_parameters", method: :get, parameters: { key: 88 })
+            respond_with(status: 203, body: "Body for parameter number")
+          end
+        end
+
+        context "and that request is made" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_with_parameters?key=88") }
+
+          it "replays the stubbed response" do
+            expect(response.code).to eql(203)
+            expect(response.body).to eql("Body for parameter number")
+          end
+
+        end
+
+      end
+
+    end
+
+    context "that contains response defaults" do
+
+      let(:configurer) { HttpStub::Examples::ConfigurerWithResponseDefaults.new }
+
+      it "includes the defaults in each response" do
+        response = Net::HTTP.get_response(server_host, "/response_with_defaults", server_port)
+
+        expect(response["defaulted_header"]).to eql("Header value")
+      end
+
+    end
+
+    describe "that contains response headers" do
+
+      context "with a content-type header" do
+
+        before(:example) do
+          stub_server.add_stub! do
+            match_requests("/some_stub_path", method: :get)
+            respond_with(body: "Some stub body", headers: { "content-type" => "application/xhtml" })
+          end
+        end
+
+        it "registers the stub" do
+          response = HTTParty.get("#{server_uri}/some_stub_path")
+
+          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
+
+          let(:response_headers) do
+            {
+              "some_header" => "some value",
+              "another_header" => "another value",
+              "yet_another_header" => "yet another value"
+            }
+          end
+
+          before(:example) do
+            stub_server.add_stub! do |stub|
+              stub.match_requests("/some_stub_path", method: :get)
+              stub.respond_with(body: "Some stub body", headers: response_headers)
+            end
+          end
+
+          it "registers the stub" do
+            response = Net::HTTP.get_response("localhost", "/some_stub_path", 8001)
+
+            response_headers.each { |key, value| expect(response[key]).to eql(value) }
+          end
+
+        end
+
+      end
+
+    end
+
+    context "that contains a response body that is a file" do
+
+      let(:configurer) { HttpStub::Examples::ConfigurerWithFileResponses.new }
+
+      context "and a request that matches is made" do
+
+        context "that matches a stub with a custom content-type" do
+
+          let(:response) { HTTParty.get("#{server_uri}/stub_response_with_file") }
+
+          it "responds with the configured status code" do
+            expect(response.code).to eql(200)
+          end
+
+          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
+
+        end
+
+        context "that matches a stub with no content-type" do
+
+          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::ConfigurerWithFileResponses::FILE_PATH)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end