http_stub 0.14.2 → 0.15.0

data/spec/lib/http_stub/{models → server}/stub_registry_spec.rb

@@ -1,14 +1,14 @@
-describe HttpStub::Models::StubRegistry do
+describe HttpStub::Server::StubRegistry do
 
-  let(:registry)      { instance_double(HttpStub::Models::Registry) }
+  let(:registry)      { instance_double(HttpStub::Server::Registry) }
 
-  let(:stub_registry) { HttpStub::Models::StubRegistry.new }
+  let(:stub_registry) { HttpStub::Server::StubRegistry.new }
 
-  before(:example) { allow(HttpStub::Models::Registry).to receive(:new).and_return(registry) }
+  before(:example) { allow(HttpStub::Server::Registry).to receive(:new).and_return(registry) }
 
   describe "#add" do
 
-    let(:stub)    { instance_double(HttpStub::Models::Stub) }
+    let(:stub)    { instance_double(HttpStub::Server::Stub) }
     let(:request) { double("HttpRequest") }
 
     it "delegates to an underlying simple registry" do
@@ -33,8 +33,8 @@ describe HttpStub::Models::StubRegistry do
 
     context "when a stub is found" do
 
-      let(:triggers) { instance_double(HttpStub::Models::StubTriggers) }
-      let(:stub)     { instance_double(HttpStub::Models::Stub, triggers: triggers) }
+      let(:triggers) { instance_double(HttpStub::Server::StubTriggers) }
+      let(:stub)     { instance_double(HttpStub::Server::Stub, triggers: triggers) }
 
       before(:example) { allow(registry).to receive(:find_for).and_return(stub) }
 
@@ -64,53 +64,33 @@ describe HttpStub::Models::StubRegistry do
 
   end
 
-  describe "#remember" do
-
-    it "copies the underlying registry" do
-      expect(registry).to receive(:copy)
-
-      stub_registry.remember
-    end
-
-  end
-
   describe "#recall" do
 
     subject { stub_registry.recall }
 
     context "when the state of the registry has been remembered" do
 
-      let(:remembered_registry)         { instance_double(HttpStub::Models::Registry) }
-      let(:copy_of_remembered_registry) { instance_double(HttpStub::Models::Registry) }
+      let(:last_stub_remembered) { instance_double(HttpStub::Server::Stub) }
 
       before(:example) do
-        allow(registry).to receive(:copy).and_return(remembered_registry)
-        allow(remembered_registry).to receive(:copy).and_return(copy_of_remembered_registry)
+        allow(registry).to receive(:last).and_return(last_stub_remembered)
         stub_registry.remember
       end
 
-      it "copies the remembered registry to ensure subsequent recalls recall the same stubs" do
-        expect(remembered_registry).to receive(:copy)
+      it "causes the underlying registry to rollback to the last stub added before the state was remembered" do
+        expect(registry).to receive(:rollback_to).with(last_stub_remembered)
 
         subject
       end
 
-      it "causes subsequent method calls to delegate to the copy" do
-        subject
-
-        expect(copy_of_remembered_registry).to receive(:all)
-        stub_registry.all
-      end
-
     end
 
     context "when the state of the registry has not been remembered" do
 
-      it "does not effect subsequent method calls" do
-        subject
+      it "does not rollback the underlying registry" do
+        expect(registry).to_not receive(:rollback_to)
 
-        expect(registry).to receive(:all)
-        stub_registry.all
+        subject
       end
 
     end
@@ -119,7 +99,7 @@ describe HttpStub::Models::StubRegistry do
 
   describe "#all" do
 
-    let(:stubs) { (1..3).map { instance_double(HttpStub::Models::Stub) } }
+    let(:stubs) { (1..3).map { instance_double(HttpStub::Server::Stub) } }
 
     subject { stub_registry.all }
 

data/spec/lib/http_stub/server/stub_response/base_spec.rb

@@ -0,0 +1,225 @@
+describe HttpStub::Server::StubResponse::Base do
+
+  let(:status)           { 202 }
+  let(:headers)          { nil }
+  let(:body)             { "A response body" }
+  let(:delay_in_seconds) { 18 }
+  let(:args) do
+    { "status" => status, "headers" => headers, "body" => body, "delay_in_seconds" => delay_in_seconds }
+  end
+
+  let(:testable_response_class) { Class.new(HttpStub::Server::StubResponse::Base) }
+
+  let(:response) { testable_response_class.new(args) }
+
+  describe "#status" do
+
+    context "when a value is provided in the arguments" do
+
+      context "that is an integer" do
+
+        it "returns the value provided" do
+          expect(response.status).to eql(status)
+        end
+
+      end
+
+      context "that is an empty string" do
+
+        let(:status) { "" }
+
+        it "defaults to 200" do
+          expect(response.status).to eql(200)
+        end
+
+      end
+
+    end
+
+    context "when the status is not provided in the arguments" do
+
+      let(:args) { { "body" => body, "delay_in_seconds" => delay_in_seconds } }
+
+      it "defaults to 200" do
+        expect(response.status).to eql(200)
+      end
+
+    end
+
+  end
+
+  describe "#body" do
+
+    it "returns the value provided in the arguments" do
+      expect(response.body).to eql("A response body")
+    end
+
+  end
+
+  describe "#delay_in_seconds" do
+
+    context "when a value is provided in the arguments" do
+
+      context "that is an integer" do
+
+        it "returns the value" do
+          expect(response.delay_in_seconds).to eql(delay_in_seconds)
+        end
+
+      end
+
+      context "that is an empty string" do
+
+        let(:delay_in_seconds) { "" }
+
+        it "defaults to 0" do
+          expect(response.delay_in_seconds).to eql(0)
+        end
+
+      end
+
+    end
+
+    context "when a value is not provided in the arguments" do
+
+      let(:args) { { "status" => status, "body" => body } }
+
+      it "defaults to 0" do
+        expect(response.delay_in_seconds).to eql(0)
+      end
+
+    end
+
+  end
+
+  describe "#headers" do
+
+    let(:response_header_hash) { response.headers.to_hash }
+
+    it "is Headers" do
+      expect(response.headers).to be_a(HttpStub::Server::Headers)
+    end
+
+    context "when default headers have been added" do
+
+      let(:default_headers) do
+        { "a_default_header" => "a default value", "another_default_header" => "some other default value" }
+      end
+
+      before(:example) { testable_response_class.add_default_headers(default_headers) }
+
+      context "and headers are provided" do
+
+        context "that have some names matching the defaults" do
+
+          let(:headers) { { "a_default_header" => "an overridde value" } }
+
+          it "replaces the matching default values with those provided" do
+            expect(response_header_hash["a_default_header"]).to eql("an overridde value")
+          end
+
+          it "preserves the default values that do not match" do
+            expect(response_header_hash["another_default_header"]).to eql("some other default value")
+          end
+
+        end
+
+        context "that do not have names matching the defaults" do
+
+          let(:headers) do
+            {
+              "a_header" => "some header",
+              "another_header" => "another value",
+              "yet_another_header" => "yet another value"
+            }
+          end
+
+          it "returns the defaults headers combined with the provided headers" do
+            expect(response_header_hash).to eql(default_headers.merge(headers))
+          end
+
+        end
+
+      end
+
+      context "and no headers are provided" do
+
+        it "returns the default headers" do
+          expect(response_header_hash).to eql(default_headers)
+        end
+
+      end
+
+    end
+
+    context "when no default headers have been added" do
+
+      context "and headers are provided" do
+
+        let(:headers) do
+          {
+            "a_header" => "some header",
+            "another_header" => "another value",
+            "yet_another_header" => "yet another value"
+          }
+        end
+
+        it "returns the headers" do
+          expect(response_header_hash).to eql(headers)
+        end
+
+      end
+
+      context "and no headers are provided" do
+
+        let(:headers) { nil }
+
+        it "returns an empty hash" do
+          expect(response_header_hash).to eql({})
+        end
+
+      end
+
+    end
+
+  end
+
+  describe "#empty?" do
+
+    context "when the response is EMPTY" do
+
+      let(:response) { HttpStub::Server::Response::EMPTY }
+
+      it "returns true" do
+        expect(response).to be_empty
+      end
+
+    end
+
+    context "when the response is not EMPTY" do
+
+      it "returns false" do
+        expect(response).not_to be_empty
+      end
+
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "executes without error" do
+      expect { response.clear }.to_not raise_error
+    end
+
+  end
+
+  describe "#to_s" do
+
+    it "returns the string representation of the provided arguments" do
+      expect(response.to_s).to eql(args.to_s)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/stub_response/file_spec.rb

@@ -0,0 +1,140 @@
+describe HttpStub::Server::StubResponse::File do
+
+  let(:status)         { 321 }
+  let(:headers)        { {} }
+  let(:file_name)      { "sample.txt" }
+  let(:temp_file_path) { "#{HttpStub::Spec::RESOURCES_DIR}/#{file_name}" }
+  let(:args) do
+    {
+      "status" => status,
+      "headers" => headers,
+      "body" => { filename: file_name, tempfile: File.new(temp_file_path) }
+    }
+  end
+
+  let(:expected_file_path) { "#{HttpStub::BASE_DIR}/tmp/response_files/#{file_name}" }
+
+  let(:response_file) { HttpStub::Server::StubResponse::File.new(args) }
+
+  after(:example) { FileUtils.rm_rf(expected_file_path) }
+
+  it "is a base response" do
+    expect(response_file).to be_a(HttpStub::Server::StubResponse::Base)
+  end
+
+  describe "constructor" do
+
+    it "stores the temporary file provided for subsequent use" do
+      response_file
+
+      expect(FileUtils.identical?(expected_file_path, temp_file_path)).to be(true)
+    end
+
+  end
+
+  describe "#serve_on" do
+
+    let(:server) { instance_double(Sinatra::Base) }
+
+    subject { response_file.serve_on(server) }
+
+    it "sends the file via the server" do
+      expect(server).to receive(:send_file).with(expected_file_path, anything)
+
+      subject
+    end
+
+    it "sends the file with the responses status" do
+      expect(server).to receive(:send_file).with(anything, hash_including(status: status))
+
+      subject
+    end
+
+    context "when a content type header is specified" do
+
+      let(:content_type) { "plain/text" }
+      let(:headers)      { { "content-type" => content_type } }
+
+      it "sends the file with a type that is the provided content type" do
+        expect(server).to receive(:send_file).with(anything, hash_including(type: content_type))
+
+        subject
+      end
+
+    end
+
+    context "when no content type header is specified" do
+
+      let(:headers) { {} }
+
+      it "sends the file with a type of application/octet-stream" do
+        expect(server).to receive(:send_file).with(anything, hash_including(type: "application/octet-stream"))
+
+        subject
+      end
+
+    end
+
+    context "when a last modified header is specified" do
+
+      let(:last_modified_date) { "Thu, 14 May 2015 12:56:00 GMT" }
+      let(:headers)            { { "last-modified" => last_modified_date } }
+
+      it "sends the file with the last modified date" do
+        expect(server).to receive(:send_file).with(anything, hash_including(last_modified: last_modified_date))
+
+        subject
+      end
+
+    end
+
+    context "when no last modified header is specified" do
+
+      let(:headers) { {} }
+
+      it "sends the file without a last modified date" do
+        expect(server).to receive(:send_file).with(anything, hash_excluding(:last_modified))
+
+        subject
+      end
+
+    end
+
+    context "when a content disposition header is specified" do
+
+      let(:content_disposition) { "attachment" }
+      let(:headers)             { { "content-disposition" => content_disposition } }
+
+      it "sends the file with a disposition whose value is the provided content disposition" do
+        expect(server).to receive(:send_file).with(anything, hash_including(disposition: content_disposition))
+
+        subject
+      end
+
+    end
+
+    context "when a content disposition header is not specified" do
+
+      let(:headers) { {} }
+
+      it "sends the file without a disposition" do
+        expect(server).to receive(:send_file).with(anything, hash_excluding(:disposition))
+
+        subject
+      end
+
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "deletes the stored file" do
+      response_file.clear
+
+      expect(File.exist?(expected_file_path)).to be(false)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/stub_response/text_spec.rb

@@ -0,0 +1,103 @@
+describe HttpStub::Server::StubResponse::Text do
+
+  let(:status)  { 123 }
+  let(:headers) { {} }
+  let(:body)    { "Some text body" }
+  let(:args) { { "status" => status, "headers" => headers, "body" => body } }
+
+  let(:response_text) { HttpStub::Server::StubResponse::Text.new(args) }
+
+  it "is a base response" do
+    expect(response_text).to be_a(HttpStub::Server::StubResponse::Base)
+  end
+
+  describe "#serve_on" do
+
+    let(:server) { instance_double(Sinatra::Base) }
+
+    subject { response_text.serve_on(server) }
+
+    it "halts processing of the servers request" do
+      expect(server).to receive(:halt)
+
+      subject
+    end
+
+    it "halts with the responses status" do
+      expect(server).to receive(:halt).with(status, anything, anything)
+
+      subject
+    end
+
+    context "when headers are provided" do
+
+      context "that contain a content-type" do
+
+        let(:headers) do
+          {
+            "content-type"       => "some/content/type",
+            "another-header"     => "some value",
+            "yet-another-header" => "some other value"
+          }
+        end
+
+        it "halts with the provided headers" do
+          expect(server).to receive(:halt).with(anything, headers, anything)
+
+          subject
+        end
+
+      end
+
+      context "that do not contain a content-type" do
+
+        let(:headers) do
+          {
+            "a-header"           => "some value",
+            "another-header"     => "another value",
+            "yet-another-header" => "yet another value"
+          }
+        end
+
+        it "halts with the provided headers" do
+          expect(server).to receive(:halt).with(anything, hash_including(headers), anything)
+
+          subject
+        end
+
+        it "halts with a default content-type of application/json" do
+          expect_server_to_halt_with_default_content_type
+
+          subject
+        end
+
+      end
+
+    end
+
+    context "when no headers are provided" do
+
+      let(:headers) { {} }
+
+      it "halts with a default content-type of application/json" do
+        expect_server_to_halt_with_default_content_type
+
+        subject
+      end
+
+    end
+
+    it "halts with the responses body" do
+      expect(server).to receive(:halt).with(anything, anything, body)
+
+      subject
+    end
+
+    def expect_server_to_halt_with_default_content_type
+      expected_content_type_entry = { "content-type" => "application/json" }
+      expect(server).to receive(:halt).with(anything, hash_including(expected_content_type_entry), anything)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/server/stub_response_spec.rb

@@ -0,0 +1,49 @@
+describe HttpStub::Server::StubResponse do
+
+  describe "::create" do
+
+    let(:response_args) { { "body" => body } }
+
+    subject { HttpStub::Server::StubResponse.create(response_args) }
+
+    context "when the body contains text" do
+
+      let(:body) { "some text" }
+
+      it "creates a text response" do
+        expect(HttpStub::Server::StubResponse::Text).to receive(:new).with(response_args)
+
+        subject
+      end
+
+      it "returns the created response" do
+        response = instance_double(HttpStub::Server::StubResponse::Text)
+        allow(HttpStub::Server::StubResponse::Text).to receive(:new).and_return(response)
+
+        expect(subject).to eql(response)
+      end
+
+    end
+
+    context "when the body contains a file" do
+
+      let(:body) { { "file" => { "path" => "a/file.path", "name" => "a_file.name" } } }
+
+      it "creates a file response" do
+        expect(HttpStub::Server::StubResponse::File).to receive(:new).with(response_args)
+
+        subject
+      end
+
+      it "returns the created response" do
+        response = instance_double(HttpStub::Server::StubResponse::File)
+        allow(HttpStub::Server::StubResponse::File).to receive(:new).and_return(response)
+
+        expect(subject).to eql(response)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/{models → server}/stub_spec.rb

@@ -1,4 +1,4 @@
-describe HttpStub::Models::Stub do
+describe HttpStub::Server::Stub do
 
   let(:raw_stub_headers) do
     {
@@ -40,25 +40,27 @@ describe HttpStub::Models::Stub do
       "triggers" => [ stub_trigger ]
     }
   end
-  let(:stub_uri)        { instance_double(HttpStub::Models::StubUri, match?: true) }
-  let(:stub_headers)    { instance_double(HttpStub::Models::StubHeaders, match?: true) }
-  let(:stub_parameters) { instance_double(HttpStub::Models::StubParameters, match?: true) }
-  let(:stub_triggers)   { instance_double(HttpStub::Models::StubTriggers) }
+  let(:stub_uri)        { instance_double(HttpStub::Server::StubUri, match?: true) }
+  let(:stub_headers)    { instance_double(HttpStub::Server::StubHeaders, match?: true) }
+  let(:stub_parameters) { instance_double(HttpStub::Server::StubParameters, match?: true) }
+  let(:stub_response)   { instance_double(HttpStub::Server::StubResponse::Base, clear: nil) }
+  let(:stub_triggers)   { instance_double(HttpStub::Server::StubTriggers, clear: nil) }
 
-  let(:the_stub) { HttpStub::Models::Stub.new(stub_args) }
+  let(:the_stub) { HttpStub::Server::Stub.new(stub_args) }
 
   before(:example) do
-    allow(HttpStub::Models::StubUri).to receive(:new).and_return(stub_uri)
-    allow(HttpStub::Models::StubHeaders).to receive(:new).and_return(stub_headers)
-    allow(HttpStub::Models::StubParameters).to receive(:new).and_return(stub_parameters)
-    allow(HttpStub::Models::StubTriggers).to receive(:new).and_return(stub_triggers)
+    allow(HttpStub::Server::StubUri).to receive(:new).and_return(stub_uri)
+    allow(HttpStub::Server::StubHeaders).to receive(:new).and_return(stub_headers)
+    allow(HttpStub::Server::StubParameters).to receive(:new).and_return(stub_parameters)
+    allow(HttpStub::Server::StubResponse).to receive(:create).and_return(stub_response)
+    allow(HttpStub::Server::StubTriggers).to receive(:new).and_return(stub_triggers)
   end
 
   describe "#satisfies?" do
 
-    let(:request_uri) { "/a_request_uri" }
+    let(:request_uri)    { "/a_request_uri" }
     let(:request_method) { stub_method }
-    let(:request) { double("HttpRequest", :request_method => request_method) }
+    let(:request)        { instance_double(Rack::Request, :request_method => request_method) }
 
     describe "when the request uri matches" do
 
@@ -170,12 +172,8 @@ describe HttpStub::Models::Stub do
 
   describe "#response" do
 
-    it "exposes the provided response status" do
-      expect(the_stub.response.status).to eql(201)
-    end
-
-    it "exposes the provided response body" do
-      expect(the_stub.response.body).to eql("Some body")
+    it "exposes the response model encapsulating the response provided in the request body" do
+      expect(the_stub.response).to eql(stub_response)
     end
 
   end
@@ -188,6 +186,24 @@ describe HttpStub::Models::Stub do
 
   end
 
+  describe "#clear" do
+
+    subject { the_stub.clear }
+
+    it "clears the stub response" do
+      expect(stub_response).to receive(:clear)
+
+      subject
+    end
+
+    it "clears the stub triggers" do
+      expect(stub_triggers).to receive(:clear)
+
+      subject
+    end
+
+  end
+
   describe "#to_s" do
 
     it "returns a string representation of the stub arguments" do