http_stub 0.13.5 → 0.14.0.rc1

data/spec/lib/http_stub/configurer/request/controllable_value_spec.rb

@@ -4,25 +4,25 @@ describe HttpStub::Configurer::Request::ControllableValue do
 
     let(:value) { "some value" }
 
-    it "should format the potential control value via the Regexpable formatter" do
-      HttpStub::Configurer::Request::Regexpable.should_receive(:format).with(value)
+    it "formats the potential control value via the Regexpable formatter" do
+      expect(HttpStub::Configurer::Request::Regexpable).to receive(:format).with(value)
 
       perform_format
     end
 
-    it "should chain formatting by formatting the Regexpable formatter result via the Omittable formatter" do
+    it "chains formatting by formatting the Regexpable formatter result via the Omittable formatter" do
       regexp_formatted_value = "some regexp formatted value"
-      HttpStub::Configurer::Request::Regexpable.stub(:format).and_return(regexp_formatted_value)
-      HttpStub::Configurer::Request::Omittable.should_receive(:format).with(regexp_formatted_value)
+      allow(HttpStub::Configurer::Request::Regexpable).to receive(:format).and_return(regexp_formatted_value)
+      expect(HttpStub::Configurer::Request::Omittable).to receive(:format).with(regexp_formatted_value)
 
       perform_format
     end
 
-    it "should return the Omittable formatter result" do
+    it "returns the Omittable formatter result" do
       omit_formatted_value = "some omit formatted value"
-      HttpStub::Configurer::Request::Omittable.stub(:format).and_return(omit_formatted_value)
+      allow(HttpStub::Configurer::Request::Omittable).to receive(:format).and_return(omit_formatted_value)
 
-      perform_format.should eql(omit_formatted_value)
+      expect(perform_format).to eql(omit_formatted_value)
     end
 
     def perform_format

data/spec/lib/http_stub/configurer/request/omittable_spec.rb

@@ -13,13 +13,13 @@ describe HttpStub::Configurer::Request::Omittable do
           end
         end
 
-        it "should return a hash containing the omitted values converted to 'control:omitted'" do
+        it "returns a hash containing the omitted values converted to 'control:omitted'" do
           expected_hash = (1..5).reduce({}) do |result, i|
             result["key#{i}"] = (i % 2 == 0) ? "value#{i}" : "control:omitted"
             result
           end
 
-          perform_format.should eql(expected_hash)
+          expect(perform_format).to eql(expected_hash)
         end
 
       end
@@ -33,8 +33,8 @@ describe HttpStub::Configurer::Request::Omittable do
           end
         end
 
-        it "should return the hash unchanged" do
-          perform_format.should eql(value)
+        it "returns the hash unchanged" do
+          expect(perform_format).to eql(value)
         end
 
       end
@@ -43,8 +43,8 @@ describe HttpStub::Configurer::Request::Omittable do
 
         let(:value) { {} }
 
-        it "should return the hash unchanged" do
-          perform_format.should eql({})
+        it "returns the hash unchanged" do
+          expect(perform_format).to eql({})
         end
 
       end
@@ -55,8 +55,8 @@ describe HttpStub::Configurer::Request::Omittable do
 
       let(:value) { "not a hash" }
 
-      it "should return the value unchanged" do
-        perform_format.should eql(value)
+      it "returns the value unchanged" do
+        expect(perform_format).to eql(value)
       end
 
     end

data/spec/lib/http_stub/configurer/request/regexpable_spec.rb

@@ -6,8 +6,8 @@ describe HttpStub::Configurer::Request::Regexpable do
 
       let(:value) { "some string value" }
 
-      it "should return the value unaltered" do
-        HttpStub::Configurer::Request::Regexpable.format(value).should eql(value)
+      it "returns the value unaltered" do
+        expect(HttpStub::Configurer::Request::Regexpable.format(value)).to eql(value)
       end
 
     end
@@ -16,20 +16,20 @@ describe HttpStub::Configurer::Request::Regexpable do
 
       let(:value) { /.+?[a-z]/ }
 
-      it "should return a string prefixed by 'regexp:'" do
-        HttpStub::Configurer::Request::Regexpable.format(value).should start_with("regexp:")
+      it "returns a string prefixed by 'regexp:'" do
+        expect(HttpStub::Configurer::Request::Regexpable.format(value)).to start_with("regexp:")
       end
 
-      it "should contain the regular expression converted to a string" do
-        HttpStub::Configurer::Request::Regexpable.format(value).should end_with(".+?[a-z]")
+      it "contains the regular expression converted to a string" do
+        expect(HttpStub::Configurer::Request::Regexpable.format(value)).to end_with(".+?[a-z]")
       end
 
       describe "and the regular expression contain escaped meta characters" do
 
         let(:value) { /\^\+\[/ }
 
-        it "should return a string that retains the escape characters" do
-          HttpStub::Configurer::Request::Regexpable.format(value).should include("\\^\\+\\[")
+        it "returns a string that retains the escape characters" do
+          expect(HttpStub::Configurer::Request::Regexpable.format(value)).to include("\\^\\+\\[")
         end
 
       end
@@ -38,8 +38,8 @@ describe HttpStub::Configurer::Request::Regexpable do
 
         let(:value) { /\/some\/path/ }
 
-        it "should represent the path separators as a single forward-slash" do
-          HttpStub::Configurer::Request::Regexpable.format(value).should end_with("/some/path")
+        it "represents the path separators as a single forward-slash" do
+          expect(HttpStub::Configurer::Request::Regexpable.format(value)).to end_with("/some/path")
         end
 
       end
@@ -52,10 +52,10 @@ describe HttpStub::Configurer::Request::Regexpable do
 
         let(:value) { { key1: "value1", key2: /^.*value2$/, key3: "value3" } }
 
-        it "should return a json representation of the hash whose values are their regexpable form" do
+        it "returns a json representation of the hash whose values are their regexpable form" do
           expected_formatted_hash = {key1: "value1", key2: "regexp:^.*value2$", key3: "value3"}
 
-          HttpStub::Configurer::Request::Regexpable.format(value).should eql(expected_formatted_hash)
+          expect(HttpStub::Configurer::Request::Regexpable.format(value)).to eql(expected_formatted_hash)
         end
 
       end
@@ -64,8 +64,8 @@ describe HttpStub::Configurer::Request::Regexpable do
 
         let(:value) { {} }
 
-        it "should return an empty hash" do
-          HttpStub::Configurer::Request::Regexpable.format(value).should eql({})
+        it "returns an empty hash" do
+          expect(HttpStub::Configurer::Request::Regexpable.format(value)).to eql({})
         end
 
       end

data/spec/lib/http_stub/configurer/request/stub_activator_payload_builder_spec.rb

@@ -0,0 +1,74 @@
+describe HttpStub::Configurer::Request::StubActivatorPayloadBuilder do
+
+  include_context "stub payload builder arguments"
+
+  let(:stub_payload) { { "stub_payload_key" => "stub payload value" } }
+  let(:stub_builder) { instance_double(HttpStub::Configurer::Request::StubPayloadBuilder, build: stub_payload) }
+
+  let(:builder) { HttpStub::Configurer::Request::StubActivatorPayloadBuilder.new }
+
+  before(:example) do
+    allow(HttpStub::Configurer::Request::StubPayloadBuilder).to receive(:new).and_return(stub_builder)
+  end
+
+  describe "#match_request" do
+
+    it "delegates to a stub payload builder" do
+      expect(stub_builder).to receive(:match_request).with(uri, request_options)
+
+      builder.match_request(uri, request_options)
+    end
+
+  end
+
+  describe "#with_response" do
+
+    it "delegates to a stub payload builder" do
+      expect(stub_builder).to receive(:with_response).with(response_options)
+
+      builder.with_response(response_options)
+    end
+
+  end
+
+  describe "#and_add_stub" do
+
+    let(:trigger_builder) { instance_double(HttpStub::Configurer::Request::StubPayloadBuilder) }
+
+    it "delegates to a stub payload builder" do
+      expect(stub_builder).to receive(:and_add_stub).with(trigger_builder)
+
+      builder.and_add_stub(trigger_builder)
+    end
+
+  end
+
+  describe "#build" do
+
+    subject { builder.build }
+
+    context "when a path is established" do
+
+      let(:activation_uri) { "http://some/activation/uri" }
+
+      before(:example) { builder.path(activation_uri) }
+
+      it "returns a payload that includes the activation uri" do
+        expect(subject).to include(activation_uri: activation_uri)
+      end
+
+      it "builds a stub payload" do
+        expect(stub_builder).to receive(:build)
+
+        subject
+      end
+
+      it "returns a payload that includes the stub payload" do
+        expect(subject).to include(stub_payload)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurer/request/stub_activator_spec.rb

@@ -2,47 +2,40 @@ describe HttpStub::Configurer::Request::StubActivator do
 
   describe "#initialize" do
 
-    let(:stub_request_body) { { key: "value" }.to_json }
-    let(:stub_request_content_type) { "Some content type" }
-    let(:stub_request) { double("StubRequest", :content_type => stub_request_content_type, :body => stub_request_body) }
+    context "when provided a payload" do
 
-    before(:each) { HttpStub::Configurer::Request::Stub.stub(:new).and_return(stub_request) }
+      let(:payload) { { payload_key: "payload value" } }
 
-    describe "when provided an activation uri, stub uri and stub options" do
+      let(:request) { HttpStub::Configurer::Request::StubActivator.new(payload) }
 
-      let(:activation_uri) { "Some activation URI" }
-      let(:stub_uri) { "Some stub URI" }
-      let(:stub_options) { "Some options" }
-
-      let(:request) { HttpStub::Configurer::Request::StubActivator.new(activation_uri, stub_uri, stub_options) }
-      let(:request_body) { JSON.parse(request.body) }
+      it "creates a HTTP POST request" do
+        expect(request.method).to eql("POST")
+      end
 
-      it "should create a HTTP POST request" do
-        request.method.should eql("POST")
+      it "submits the request to '/stubs/activators'" do
+        expect(request.path).to eql("/stubs/activators")
       end
 
-      it "should submit the request to '/stubs/activators'" do
-        request.path.should eql("/stubs/activators")
+      it "sets the content type to json" do
+        expect(request.content_type).to eql("application/json")
       end
 
-      it "should set the content type to the same as a stub request" do
-        request.content_type.should eql(stub_request_content_type)
+      it "sets the body to the JSON representation of the provided payload" do
+        expect(request.body).to eql(payload.to_json)
       end
 
-      describe "generates a JSON body which" do
+    end
 
-        it "should contain entries for a stub request" do
-          HttpStub::Configurer::Request::Stub.should_receive(:new).with(stub_uri, stub_options).and_return(stub_request)
+  end
 
-          request_body.should include(JSON.parse(stub_request_body))
-        end
+  describe "#activation_uri" do
 
-        it "should have an entry for the provided activation URI" do
-          request_body.should include({ "activation_uri" => activation_uri })
-        end
+    let(:activation_uri) { "http://some/activation/uri" }
 
-      end
+    let(:request) { HttpStub::Configurer::Request::StubActivator.new(activation_uri: activation_uri) }
 
+    it "should return the activation uri from the payload" do
+      expect(request.activation_uri).to eql(activation_uri)
     end
 
   end

data/spec/lib/http_stub/configurer/request/stub_payload_builder_spec.rb

@@ -0,0 +1,203 @@
+describe HttpStub::Configurer::Request::StubPayloadBuilder do
+
+  let(:builder) { HttpStub::Configurer::Request::StubPayloadBuilder.new }
+
+  shared_context "add stub triggers" do
+
+    let(:trigger_payloads) { (1..3).map { |i| { "trigger_#{i}_key" => "trigger #{i} value" } } }
+    let(:trigger_builders) do
+      trigger_payloads.map do |payload|
+        instance_double(HttpStub::Configurer::Request::StubPayloadBuilder, build: payload)
+      end
+    end
+
+    before(:example) { trigger_builders.each { |trigger_builder| builder.and_add_stub(trigger_builder) } }
+
+  end
+
+  describe "#build" do
+
+    context "when provided a uri and stub arguments" do
+
+      include_context "stub payload builder arguments"
+
+      subject { builder.build }
+
+      before(:example) do
+        allow(HttpStub::Configurer::Request::ControllableValue).to receive(:format)
+
+        builder.match_request(uri, request_options)
+        builder.with_response(response_options)
+      end
+
+      context "when request header is provided" do
+
+        it "formats the headers into control values" do
+          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(request_headers)
+
+          subject
+        end
+
+      end
+
+      context "when no request header is provided" do
+
+        let(:request_headers) { nil }
+
+        it "formats an empty header hash" do
+          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
+
+          subject
+        end
+
+      end
+
+      context "when a request parameter is provided" do
+
+        it "formats the request parameters into control values" do
+          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with(request_parameters)
+
+          subject
+        end
+
+      end
+
+      context "when no request parameter is provided" do
+
+        let(:request_parameters) { nil }
+
+        it "formats an empty parameter hash" do
+          expect(HttpStub::Configurer::Request::ControllableValue).to receive(:format).with({})
+
+          subject
+        end
+
+      end
+
+      context "when stub triggers are added" do
+        
+        include_context "add stub triggers"
+
+        it "builds the payload for each trigger" do
+          trigger_builders.each { |trigger_builder| expect(trigger_builder).to receive(:build) }
+
+          subject
+        end
+
+      end
+
+      context "builds a request payload" do
+
+        it "has an entry containing the control value representation of the uri" do
+          allow(HttpStub::Configurer::Request::ControllableValue).to(
+            receive(:format).with(uri).and_return("uri as a string")
+          )
+
+          expect(subject).to include(uri: "uri as a string")
+        end
+
+        it "has an entry for the method option" do
+          expect(subject).to include(method: stub_method)
+        end
+
+        it "has an entry containing the string representation of the request headers" do
+          allow(HttpStub::Configurer::Request::ControllableValue).to(
+            receive(:format).with(request_headers).and_return("request headers as string")
+          )
+
+          expect(subject).to include(headers: "request headers as string")
+        end
+
+        it "has an entry containing the string representation of the request parameters" do
+          allow(HttpStub::Configurer::Request::ControllableValue).to(
+            receive(:format).with(request_parameters).and_return("request parameters as string")
+          )
+
+          expect(subject).to include(parameters: "request parameters as string")
+        end
+
+        context "when a status response argument is provided" do
+
+          it "has a response entry for the argument" do
+            expect(subject[:response]).to include(status: response_status)
+          end
+
+        end
+
+        context "when no status response argument is provided" do
+
+          let(:response_status) { nil }
+
+          it "has a response entry with an empty status code" do
+            expect(subject[:response]).to include(status: "")
+          end
+
+        end
+
+        context "when response headers are provided" do
+
+          let(:response_headers) { { response_header_name: "value" } }
+
+          it "has a headers response entry containing the the provided headers" do
+            expect(subject[:response]).to include(headers: response_headers)
+          end
+
+        end
+
+        context "when response headers are omitted" do
+
+          let (:response_headers) { nil }
+
+          it "has a headers response entry containing an empty hash" do
+            expect(subject[:response]).to include(headers: {})
+          end
+
+        end
+
+        it "has an entry for the response body argument" do
+          expect(subject[:response]).to include(body: response_body)
+        end
+
+        context "when a delay option is provided" do
+
+          it "has a response entry for the argument" do
+            expect(subject[:response]).to include(delay_in_seconds: response_delay_in_seconds)
+          end
+
+        end
+
+        context "when a delay option is omitted" do
+
+          let(:response_delay_in_seconds) { nil }
+
+          it "has a response entry with an empty delay" do
+            expect(subject[:response]).to include(delay_in_seconds: "")
+          end
+
+        end
+
+        context "when stub triggers are added" do
+          
+          include_context "add stub triggers"
+
+          it "has a triggers entry containing the stub trigger payloads" do
+            expect(subject).to include(triggers: trigger_payloads)
+          end
+
+        end
+
+        context "when no stub triggers are added" do
+
+          it "has a triggers entry containing an empty hash" do
+            expect(subject).to include(triggers: [])
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end