http_stub 0.13.5 → 0.14.0.rc1

data/spec/lib/http_stub/server_daemon_spec.rb

@@ -4,52 +4,52 @@ describe HttpStub::ServerDaemon do
 
   let(:server_daemon) { HttpStub::ServerDaemon.new(name: :sample_server_daemon, port: 8888, configurer: configurer) }
 
-  before(:each) { server_daemon.logger.stub(:info) }
+  before(:example) { allow(server_daemon.logger).to receive(:info) }
 
   describe ".log_dir" do
 
-    before(:each) { @original_log_dir = HttpServerManager.log_dir }
+    before(:example) { @original_log_dir = HttpServerManager.log_dir }
 
-    after(:each) { HttpServerManager.log_dir = @original_log_dir }
+    after(:example) { HttpServerManager.log_dir = @original_log_dir }
 
-    it "should establish the HttpServerManager log_dir" do
+    it "establishes the HttpServerManager log_dir" do
       HttpStub::ServerDaemon.log_dir = "/some/log/dir"
 
-      HttpServerManager.log_dir.should eql("/some/log/dir")
+      expect(HttpServerManager.log_dir).to eql("/some/log/dir")
     end
 
   end
 
   describe ".pid_dir" do
 
-    before(:each) { @original_pid_dir = HttpServerManager.pid_dir }
+    before(:example) { @original_pid_dir = HttpServerManager.pid_dir }
 
-    after(:each) { HttpServerManager.pid_dir = @original_pid_dir }
+    after(:example) { HttpServerManager.pid_dir = @original_pid_dir }
 
-    it "should establish the HttpServerManager pid_dir" do
+    it "establishes the HttpServerManager pid_dir" do
       HttpStub::ServerDaemon.pid_dir = "/some/pid/dir"
 
-      HttpServerManager.pid_dir.should eql("/some/pid/dir")
+      expect(HttpServerManager.pid_dir).to eql("/some/pid/dir")
     end
 
   end
 
   describe "#start!" do
 
-    before(:each) { server_daemon.stub(:running?).and_return(true) }
+    before(:example) { allow(server_daemon).to receive(:running?).and_return(true) }
 
     context "when a configurer is provided" do
 
       let(:configurer) { double(HttpStub::Configurer).as_null_object }
 
-      it "should initialize the configurer" do
-        configurer.should_receive(:initialize!)
+      it "initializes the configurer" do
+        expect(configurer).to receive(:initialize!)
 
         server_daemon.start!
       end
 
-      it "should log that the server with the provided name has been initialized" do
-        server_daemon.logger.should_receive(:info).with("sample_server_daemon initialized")
+      it "logs that the server with the provided name has been initialized" do
+        expect(server_daemon.logger).to receive(:info).with("sample_server_daemon initialized")
 
         server_daemon.start!
       end
@@ -58,8 +58,8 @@ describe HttpStub::ServerDaemon do
 
     context "when no configurer is provided" do
 
-      it "should not log that the server has been initialized" do
-        server_daemon.logger.should_not_receive(:info).with("sample_server_daemon initialized")
+      it "does not log that the server has been initialized" do
+        expect(server_daemon.logger).not_to receive(:info).with("sample_server_daemon initialized")
 
         server_daemon.start!
       end

data/spec/lib/http_stub/server_integration_spec.rb

@@ -8,22 +8,22 @@ describe HttpStub::Server, "when the server is running" do
 
     context "when provided with the minimum data required" do
 
-      before(:each) do
+      before(:example) do
         @response = HTTParty.post(
           "#{server_uri}/stubs",
           body: { uri: "/some/path", method: "get", response: { status: 200, body: "Some body" } }.to_json
         )
       end
 
-      it "should return a 200 response code" do
-        @response.code.should eql(200)
+      it "returns a 200 response code" do
+        expect(@response.code).to eql(200)
       end
 
-      it "should register a stub returning the provided response for a matching request" do
+      it "registers a stub returning the provided response for a matching request" do
         stubbed_response = HTTParty.get("#{server_uri}/some/path")
 
-        stubbed_response.code.should eql(200)
-        stubbed_response.body.should eql("Some body")
+        expect(stubbed_response.code).to eql(200)
+        expect(stubbed_response.body).to eql("Some body")
       end
 
     end
@@ -32,104 +32,151 @@ describe HttpStub::Server, "when the server is running" do
 
   describe "and a configurer with multiple stub activators is initialized" do
 
-    before(:all) do
-      HttpStub::Examples::ConfigurerWithManyActivators.host(server_host)
-      HttpStub::Examples::ConfigurerWithManyActivators.port(server_port)
-      HttpStub::Examples::ConfigurerWithManyActivators.initialize!
+    before(:context) do
+      configurer = HttpStub::Examples::ConfigurerWithManyActivators
+      configurer.host(server_host)
+      configurer.port(server_port)
+      configurer.initialize!
     end
 
-    describe "GET #stubs/activators" do
-
-      let(:response) { HTTParty.get("#{server_uri}/stubs/activators") }
-      let(:response_document) { Nokogiri::HTML(response.body) }
+    shared_context "the response contains HTML describing the configurers stubs" do
 
-      it "should return a 200 response code" do
-        response.code.should eql(200)
+      it "returns a 200 response code" do
+        expect(response.code).to eql(200)
       end
 
-      it "should return response whose body contains a link to each activator in alphabetical order" do
-        response_document.css("a").each_with_index do |link, i|
-          link['href'].should eql("/activator_#{i + 1}")
+      it "returns a response whose body contains the uri of each stub" do
+        (1..3).each do |stub_number|
+          expect(response.body).to match(/#{escape_html("/path_#{stub_number}")}/)
         end
       end
 
-      it "should return a response whose body contains the uri of each activators stub" do
-        (1..3).each { |i| response.body.should match(/#{escape_html("/path_#{i}")}/) }
+      it "returns a response whose body contains the uri of each stub trigger" do
+        (1..3).each do |stub_number|
+          (1..3).each do |trigger_number|
+            expect(response.body).to match(/#{escape_html("/path_#{stub_number}_trigger_#{trigger_number}")}/)
+          end
+        end
       end
 
-      it "should return a response whose body contains the request headers of each activators stub" do
-        (1..3).each { |i| response.body.should match(/request_header_#{i}:request_header_value_#{i}/) }
+      it "returns a response whose body contains the request headers of each stub" do
+        (1..3).each do |stub_number|
+          expect(response.body).to match(/request_header_#{stub_number}:request_header_value_#{stub_number}/)
+        end
       end
 
-      it "should return a response whose body contains the parameters of each activators stub" do
-        (1..3).each { |i| response.body.should match(/parameter_#{i}=parameter_value_#{i}/) }
+      it "returns a response whose body contains the request headers of each stub trigger" do
+        (1..3).each do |stub_number|
+          (1..3).each do |trigger_number|
+            expected_header_key = "request_header_#{stub_number}_trigger_#{trigger_number}"
+            expected_header_value = "request_header_value_#{stub_number}_trigger_#{trigger_number}"
+            expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
+          end
+        end
       end
 
-      it "should return a response whose body contains the response status of each activators stub" do
-        (1..3).each { |i| response.body.should match(/20#{i}/) }
+      it "returns a response whose body contains the parameters of each stub" do
+        (1..3).each do |stub_number|
+          expect(response.body).to match(/parameter_#{stub_number}=parameter_value_#{stub_number}/)
+        end
       end
 
-      it "should return a response whose body contains the response headers of each activators stub" do
-        (1..3).each { |i| response.body.should match(/response_header_#{i}:response_header_value_#{i}/) }
+      it "returns a response whose body contains the parameters of each stub trigger" do
+        (1..3).each do |stub_number|
+          (1..3).each do |trigger_number|
+            expected_parameter_key = "parameter_#{stub_number}_trigger_#{trigger_number}"
+            expected_parameter_value = "parameter_value_#{stub_number}_trigger_#{trigger_number}"
+            expect(response.body).to match(/#{expected_parameter_key}=#{expected_parameter_value}/)
+          end
+        end
       end
 
-      it "should return a response whose body contains the response body of each activators stub" do
-        response.body.should match(/Plain text body/)
-        response.body.should match(/#{escape_html({ "key" => "JSON body" }.to_json)}/)
-        response.body.should match(/#{escape_html("<html><body>HTML body</body></html>")}/)
+      it "returns a response whose body contains the response status of each stub" do
+        (1..3).each { |stub_number| expect(response.body).to match(/20#{stub_number}/) }
       end
 
-      it "should return a response whose body contains the response delay of each activators stub" do
-        (1..3).each { |i| response.body.should include("#{i * 8}") }
+      it "returns a response whose body contains the response status of each stub trigger" do
+        (1..3).each do |stub_number|
+          (1..3).each do |trigger_number|
+            expect(response.body).to match(/30#{stub_number * trigger_number}/)
+          end
+        end
       end
 
-    end
+      it "returns a response whose body contains the response headers of each stub" do
+        (1..3).each do |stub_number|
+          expected_header_key = "response_header_#{stub_number}"
+          expected_header_value = "response_header_value_#{stub_number}"
+          expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
+        end
+      end
 
-    describe "GET #stubs" do
+      it "returns a response whose body contains the response headers of each stub trigger" do
+        (1..3).each do |stub_number|
+          (1..3).each do |trigger_number|
+            expected_header_key = "response_header_#{stub_number}_trigger_#{trigger_number}"
+            expected_header_value = "response_header_value_#{stub_number}_trigger_#{trigger_number}"
+            expect(response.body).to match(/#{expected_header_key}:#{expected_header_value}/)
+          end
+        end
+      end
 
-      describe "when multiple stubs are configured" do
+      it "returns a response whose body contains the response body of each stub" do
+        expect(response.body).to match(/Plain text body/)
+        expect(response.body).to match(/#{escape_html({ "key" => "JSON body" }.to_json)}/)
+        expect(response.body).to match(/#{escape_html("<html><body>HTML body</body></html>")}/)
+      end
 
-        before(:all) do
-          (1..3).each { |i| HTTParty.get("#{server_uri}/activator_#{i}") }
+      it "returns a response whose body contains the response body of each stub trigger" do
+        (1..3).each do |stub_number|
+          (1..3).each do |trigger_number|
+            expect(response.body).to match(/Body of activator #{stub_number}_trigger_#{trigger_number}/)
+          end
         end
+      end
 
-        let(:response) { HTTParty.get("#{server_uri}/stubs") }
-        let(:response_document) { Nokogiri::HTML(response.body) }
+      it "returns a response whose body contains the response delay of each stub" do
+        (1..3).each { |stub_number| expect(response.body).to include("#{8 * stub_number}") }
+      end
 
-        it "should return a 200 response code" do
-          response.code.should eql(200)
+      it "returns a response whose body contains the response delay of each stub trigger" do
+        (1..3).each do |stub_number|
+          (1..3).each do |trigger_number|
+            expect(response.body).to include("#{3 * stub_number * trigger_number}")
+          end
         end
+      end
 
-        it "should return a response whose body contains the uri of each stub" do
-          (1..3).each { |i| response.body.should match(/#{escape_html("/path_#{i}")}/) }
-        end
+    end
 
-        it "should return a response whose body contains the headers of each stub" do
-          (1..3).each { |i| response.body.should match(/request_header_#{i}:request_header_value_#{i}/) }
-        end
+    describe "GET #stubs/activators" do
 
-        it "should return a response whose body contains the parameters of each stub" do
-          (1..3).each { |i| response.body.should match(/parameter_#{i}=parameter_value_#{i}/) }
-        end
+      let(:response)          { HTTParty.get("#{server_uri}/stubs/activators") }
+      let(:response_document) { Nokogiri::HTML(response.body) }
 
-        it "should return a response whose body contains the response status of each stub" do
-          (1..3).each { |i| response.body.should match(/20#{i}/) }
+      it "returns response whose body contains links to each activator in alphabetical order" do
+        response_document.css("a").each_with_index do |link, i|
+          expect(link['href']).to eql("/activator_#{i + 1}")
         end
+      end
 
-        it "should return a response whose body contains the response headers of each stub" do
-          (1..3).each { |i| response.body.should match(/response_header_#{i}:response_header_value_#{i}/) }
-        end
+      include_context "the response contains HTML describing the configurers stubs"
 
-        it "should return a response whose body contains the response body of each stub" do
-          response.body.should match(/Plain text body/)
-          response.body.should match(/#{escape_html({ "key" => "JSON body" }.to_json)}/)
-          response.body.should match(/#{escape_html("<html><body>HTML body</body></html>")}/)
-        end
+    end
+
+    describe "GET #stubs" do
+
+      describe "when multiple stubs are configured" do
 
-        it "should return a response whose body contains the response delay of each stub" do
-          (1..3).each { |i| response.body.should include("#{i * 8}") }
+        before(:context) do
+          (1..3).each { |i| HTTParty.get("#{server_uri}/activator_#{i}") }
         end
 
+        let(:response)          { HTTParty.get("#{server_uri}/stubs") }
+        let(:response_document) { Nokogiri::HTML(response.body) }
+
+        include_context "the response contains HTML describing the configurers stubs"
+
       end
 
     end

data/spec/lib/http_stub/server_spec.rb

@@ -1,168 +1,228 @@
 describe HttpStub::Server do
   include Rack::Test::Methods
 
-  let(:response) { last_response }
+  let(:response)      { last_response }
   let(:response_body) { response.body.to_s }
 
-  let(:stub_registry) { double(HttpStub::Models::Registry).as_null_object }
-  let(:stub_activator_registry) { double(HttpStub::Models::Registry).as_null_object }
+  let(:stub_registry)           { instance_double(HttpStub::Models::StubRegistry).as_null_object }
+  let(:stub_activator_registry) { instance_double(HttpStub::Models::Registry).as_null_object }
 
-  let(:stub_controller) { double(HttpStub::Controllers::StubController).as_null_object }
-  let(:stub_activator_controller) { double(HttpStub::Controllers::StubActivatorController).as_null_object }
+  let(:stub_controller)           { instance_double(HttpStub::Controllers::StubController).as_null_object }
+  let(:stub_activator_controller) { instance_double(HttpStub::Controllers::StubActivatorController).as_null_object }
 
   let(:app) { HttpStub::Server.new! }
 
-  before(:each) do
-    HttpStub::Models::Registry.stub(:new).with("stub").and_return(stub_registry)
-    HttpStub::Models::Registry.stub(:new).with("stub_activator").and_return(stub_activator_registry)
-    HttpStub::Controllers::StubController.stub(:new).and_return(stub_controller)
-    HttpStub::Controllers::StubActivatorController.stub(:new).and_return(stub_activator_controller)
+  before(:example) do
+    allow(HttpStub::Models::StubRegistry).to receive(:new).and_return(stub_registry)
+    allow(HttpStub::Models::Registry).to receive(:new).with("stub_activator").and_return(stub_activator_registry)
+    allow(HttpStub::Controllers::StubController).to receive(:new).and_return(stub_controller)
+    allow(HttpStub::Controllers::StubActivatorController).to receive(:new).and_return(stub_activator_controller)
   end
 
-  context "when a stub insertion is received" do
+  context "when a stub insertion request is received" do
 
-    it "should register the insertion via the stub controller" do
-      stub_controller.should_receive(:register).and_return(HttpStub::Models::Response::SUCCESS)
+    subject do
+      post "/stubs", {
+        uri: "/a_path", method: "a method",
+        response: { status: 200, body: "Foo" }
+      }.to_json
+    end
+
+    it "registers the insertion via the stub controller" do
+      expect(stub_controller).to receive(:register).and_return(HttpStub::Models::Response::SUCCESS)
 
-      issue_stub_request
+      subject
     end
 
-    it "should respond with the response provided by the controller" do
-      stub_controller.stub(:register).and_return(HttpStub::Models::Response.new("status" => 202, "body" => ""))
+    it "responds with the response provided by the controller" do
+      allow(stub_controller).to receive(:register).and_return(HttpStub::Models::Response.new("status" => 202, "body" => ""))
 
-      issue_stub_request
+      subject
 
-      response.status.should eql(202)
+      expect(response.status).to eql(202)
     end
 
-    def issue_stub_request
-      post "/stubs", {
-        uri: "/a_path", method: "a method",
-        response: { status: 200, body: "Foo" }
-      }.to_json
+  end
+
+  context "when a request to commit the stubs to memory is received" do
+
+    subject { post "/stubs/memory" }
+
+    it "remembers the stubs in the stub registry" do
+      expect(stub_registry).to receive(:remember)
+
+      subject
+    end
+
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
     end
 
   end
 
-  context "when a stub activator insertion request is received" do
+  context "when a request to recall the stubs in memory is received" do
+
+    subject { get "/stubs/memory" }
 
-    it "should register the insertion via the stub activator controller" do
-      stub_activator_controller.should_receive(:register).and_return(HttpStub::Models::Response::SUCCESS)
+    it "recalls the stubs remembered by the stub registry" do
+      expect(stub_registry).to receive(:recall)
 
-      issue_stub_activator_request
+      subject
     end
 
-    it "should respond with the response provided by the controller" do
-      stub_activator_controller.stub(:register).and_return(
-        HttpStub::Models::Response.new("status" => 302, "body" => "")
-      )
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
+    end
+
+  end
+
+  context "when a request to clear the stubs has been received" do
+
+    subject { delete "/stubs" }
 
-      issue_stub_activator_request
+    it "delegates clearing to the stub controller" do
+      expect(stub_controller).to receive(:clear)
 
-      response.status.should eql(302)
+      subject
     end
 
-    def issue_stub_activator_request
-      post "/stubs/activators", {
-          activation_uri: "/an_activation_path", uri: "/a_path", method: "a method",
-          response: { status: 200, body: "Foo" }
-      }.to_json
+    it "responds with a 200 status code" do
+      subject
+
+      expect(response.status).to eql(200)
     end
 
   end
 
-  context "when a request to clear the stubs has been received" do
+  context "when a stub activator insertion request is received" do
+
+    subject do
+      post "/stubs/activators", {
+        activation_uri: "/an_activation_path", uri: "/a_path", method: "a method",
+        response: { status: 200, body: "Foo" }
+      }.to_json
+    end
 
-    it "should delegate clearing to the stub controller" do
-      stub_controller.should_receive(:clear)
+    it "registers the insertion via the stub activator controller" do
+      expect(stub_activator_controller).to receive(:register).and_return(HttpStub::Models::Response::SUCCESS)
 
-      delete "/stubs"
+      subject
     end
 
-    it "should respond with a 200 status code" do
-      delete "/stubs"
+    it "responds with the response provided by the controller" do
+      allow(stub_activator_controller).to(
+        receive(:register).and_return(HttpStub::Models::Response.new("status" => 302, "body" => ""))
+      )
+
+      subject
 
-      response.status.should eql(200)
+      expect(response.status).to eql(302)
     end
 
   end
 
   context "when a request to clear the stub activators has been received" do
 
-    it "should delegate clearing to the stub activator controller" do
-      stub_activator_controller.should_receive(:clear)
+    subject { delete "/stubs/activators" }
 
-      delete "/stubs/activators"
+    it "delegates clearing to the stub activator controller" do
+      expect(stub_activator_controller).to receive(:clear)
+
+      subject
     end
 
-    it "should respond with a 200 status code" do
-      delete "/stubs/activators"
+    it "responds with a 200 status code" do
+      subject
 
-      response.status.should eql(200)
+      expect(response.status).to eql(200)
     end
 
   end
 
   context "when another type of request is received" do
 
+    subject { get "/a_path" }
+
     context "and the stub controller replays a response" do
 
-      before(:each) do
-        stub_controller.stub(:replay).and_return(HttpStub::Models::Response.new("status" => 222, "body" => "Some body"))
+      let(:controller_response) do
+        HttpStub::Models::Response.new(
+          "status" =>  222,
+          "headers" => { "content-type" => "application/xhtml" },
+          "body" =>    "Some body"
+        )
+      end
+
+      before(:example) { allow(stub_controller).to receive(:replay).and_return(controller_response) }
+
+      it "responds with the replay status code" do
+        subject
+
+        expect(response.status).to eql(222)
       end
 
-      it "should respond with the replay status code" do
-        get "/a_path"
+      it "responds with the replay body" do
+        subject
 
-        response.status.should eql(222)
+        expect(response_body).to eql("Some body")
       end
 
-      it "should respond with the replay body" do
-        get "/a_path"
+      it "responds with the replay content type" do
+        subject
 
-        response_body.should eql("Some body")
+        expect(response.content_type).to eql("application/xhtml")
+      end
+
+      it "allows the request pipeline to process the response before the processing of the request halts" do
+        expect(HttpStub::Models::RequestPipeline).to receive(:before_halt).with(controller_response)
+
+        subject
       end
 
     end
 
     context "and the stub controller does not replay a response" do
 
-      before(:each) do
-        stub_controller.stub(:replay).and_return(HttpStub::Models::Response::EMPTY)
+      before(:example) do
+        allow(stub_controller).to receive(:replay).and_return(HttpStub::Models::Response::EMPTY)
       end
 
       context "but the stub activator controller activates a stub" do
 
-        before(:each) do
-          stub_activator_controller.stub(:activate).and_return(
+        before(:example) do
+          allow(stub_activator_controller).to receive(:activate).and_return(
             HttpStub::Models::Response.new("status" => 300, "body" => "A body")
           )
         end
 
-        it "should respond with the activation response status code" do
-          get "/a_path"
+        it "responds with the activation response status code" do
+          subject
 
-          response.status.should eql(300)
+          expect(response.status).to eql(300)
         end
 
-        it "should respond with the activation response body" do
-          get "/a_path"
+        it "responds with the activation response body" do
+          subject
 
-          response_body.should eql("A body")
+          expect(response_body).to eql("A body")
         end
 
       end
 
       context "and the stub activator controller does not activate a stub" do
 
-        before(:each) do
-          stub_activator_controller.stub(:activate).and_return(HttpStub::Models::Response::EMPTY)
+        before(:example) do
+          allow(stub_activator_controller).to receive(:activate).and_return(HttpStub::Models::Response::EMPTY)
         end
 
-        it "should respond with a 404 status code" do
-          get "/a_path"
+        it "responds with a 404 status code" do
+          subject
 
-          response.status.should eql(404)
+          expect(response.status).to eql(404)
         end
 
       end
@@ -171,26 +231,4 @@ describe HttpStub::Server do
 
   end
 
-  context "when a request to replay a stub is received" do
-
-    it "should handle processing of the response via the request pipeline" do
-      HttpStub::Models::RequestPipeline.should_receive(:before_halt).with(duck_type(:status, :body))
-
-      get "/some/stubbed/uri"
-    end
-
-    it "should respond with the response's content type" do
-      stub_controller.stub(:replay).and_return(
-        HttpStub::Models::Response.new(
-          "status" => 200, "headers" => { "content-type" => "application/xhtml" }, "body" => "A body"
-        )
-      )
-
-      get "/some/stubbed/uri"
-
-      response.content_type.should eql("application/xhtml")
-    end
-
-  end
-
 end