http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/server/stub/response/file_spec.rb

@@ -1,197 +0,0 @@
-describe HttpStub::Server::Stub::Response::File do
-
-  let(:headers)         { {} }
-  let(:file_name)       { "sample.txt" }
-  let(:temp_file_path)  { "#{HttpStub::Spec::RESOURCES_DIR}/#{file_name}" }
-  let(:body)            { { filename: file_name, tempfile: File.new(temp_file_path) } }
-  let(:additional_args) { {} }
-  let(:args)            { { "headers" => headers, "body" => body }.merge(additional_args) }
-
-  let(:response_file) { HttpStub::Server::Stub::Response::File.new(args) }
-
-  it "is a base response" do
-    expect(response_file).to be_a(HttpStub::Server::Stub::Response::Base)
-  end
-
-  describe "#uri" do
-
-    subject { response_file.uri }
-
-    it "is prefixed with 'file://' to support display within a hyperlink" do
-      expect(subject).to start_with("file://")
-    end
-
-    it "concludes with the path to the temp file provided" do
-      expect(subject).to end_with(temp_file_path)
-    end
-
-  end
-
-  describe "#with_values_from" do
-
-    let(:request)              { instance_double(HttpStub::Server::Request::Request) }
-    let(:interpolated_headers) { { interpolated_header_name: "some interpolated header value" } }
-    let(:response_headers)     do
-      instance_double(HttpStub::Server::Stub::Response::Attribute::Headers, with_values_from: interpolated_headers)
-    end
-
-    subject { response_file.with_values_from(request) }
-
-    before(:example) do
-      allow(HttpStub::Server::Stub::Response::Attribute::Headers).to receive(:new).and_return(response_headers)
-      ensure_response_file_is_created!
-    end
-
-    it "interpolates headers with values from the request" do
-      expect(response_headers).to receive(:with_values_from).with(request)
-
-      subject
-    end
-
-    it "creates a new response file with the interpolated headers" do
-      expect(described_class).to receive(:new).with(hash_including("headers" => interpolated_headers))
-
-      subject
-    end
-
-    it "creates a new response file with other arguments preserved" do
-      expect(described_class).to receive(:new).with(hash_including("body" => body))
-
-      subject
-    end
-
-    it "returns the created file response" do
-      new_file_response = instance_double(described_class)
-      expect(described_class).to receive(:new).and_return(new_file_response)
-
-      expect(subject).to eql(new_file_response)
-    end
-
-    def ensure_response_file_is_created!
-      response_file
-    end
-
-  end
-
-  describe "#serve_on" do
-
-    let(:status)          { 321 }
-    let(:additional_args) { { "status" => status } }
-    let(:server_response) { instance_double(Sinatra::Response, status: 200) }
-    let(:server)          { instance_double(Sinatra::Base, response: server_response) }
-
-    subject { response_file.serve_on(server) }
-
-    it "sends the temp file via the server" do
-      expect(server).to receive(:send_file).with(temp_file_path, anything)
-
-      subject
-    end
-
-    it "sends the file without any provided response status to ensure that 304 responses are honoured" do
-      expect(server).to receive(:send_file).with(anything, hash_excluding(:status))
-
-      subject
-    end
-
-    it "updates the responses status to reflect the status evaluated by Sinatra" do
-      expect(server).to receive(:send_file).ordered
-      expect(server_response).to receive(:status).and_return(304).ordered
-
-      subject
-
-      expect(response_file.status).to eql(304)
-    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 "#to_hash" do
-
-    subject { response_file.to_hash }
-
-    it "contains the files uri" do
-      expect(subject).to include(file_uri: response_file.uri)
-    end
-
-    it "contains the standard response elements" do
-      expect(subject).to include(headers: response_file.headers)
-    end
-
-  end
-
-end

data/spec/lib/http_stub/server/stub/response/text_spec.rb

@@ -1,182 +0,0 @@
-describe HttpStub::Server::Stub::Response::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::Stub::Response::Text.new(args) }
-
-  describe "#body" do
-
-    it "returns the value provided in the arguments" do
-      expect(response_text.body).to eql("Some text body")
-    end
-
-  end
-
-  it "is a base response" do
-    expect(response_text).to be_a(HttpStub::Server::Stub::Response::Base)
-  end
-
-  describe "#with_values_from" do
-
-    let(:request)              { instance_double(HttpStub::Server::Request::Request) }
-    let(:interpolated_headers) { { interpolated_header_name: "some interpolated header value" } }
-    let(:response_headers)     do
-      instance_double(HttpStub::Server::Stub::Response::Attribute::Headers, with_values_from: interpolated_headers)
-    end
-    let(:interpolated_body)    { "some interpolated body" }
-    let(:response_body)        do
-      instance_double(HttpStub::Server::Stub::Response::Attribute::Body, with_values_from: interpolated_body )
-    end
-
-    subject { response_text.with_values_from(request) }
-
-    before(:example) do
-      allow(HttpStub::Server::Stub::Response::Attribute::Headers).to receive(:new).and_return(response_headers)
-      allow(HttpStub::Server::Stub::Response::Attribute::Body).to receive(:new).and_return(response_body)
-      ensure_response_text_is_created!
-    end
-
-    it "interpolates headers with values from the request" do
-      expect(response_headers).to receive(:with_values_from).with(request)
-
-      subject
-    end
-
-    it "creates a new response text with the interpolated headers" do
-      expect(described_class).to receive(:new).with(hash_including("headers" => interpolated_headers))
-
-      subject
-    end
-
-    it "creates a new response text with the interpolated body" do
-      expect(described_class).to receive(:new).with(hash_including("body" => interpolated_body))
-
-      subject
-    end
-
-    it "creates a new response text with other arguments preserved" do
-      expect(described_class).to receive(:new).with(hash_including("status" => status))
-
-      subject
-    end
-
-    it "returns the created text response" do
-      new_text_response = instance_double(described_class)
-      expect(described_class).to receive(:new).and_return(new_text_response)
-
-      expect(subject).to eql(new_text_response)
-    end
-
-    def ensure_response_text_is_created!
-      response_text
-    end
-
-  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
-
-  describe "#to_hash" do
-
-    subject { response_text.to_hash }
-
-    it "contains the responses body" do
-      expect(subject).to include(body: response_text.body)
-    end
-
-    it "contains the standard response elements" do
-      expect(subject).to include(headers: response_text.headers)
-    end
-
-  end
-
-end

data/spec/resources/sample.txt

@@ -1 +0,0 @@
-Some sample text

data/spec/support/http_stub/configurer_integration.rb

@@ -1,24 +0,0 @@
-shared_context "configurer integration" do
-  include_context "server integration"
-
-  let(:configurer_specification)           { {} }
-  let(:effective_configurer_specification) do
-    { class: HttpStub::EmptyConfigurer, initialize: true }.merge(configurer_specification)
-  end
-
-  let(:server_specification) { effective_configurer_specification.slice(:name, :port) }
-
-  let(:configurer)  { effective_configurer_specification[:class] }
-  let(:stub_server) { configurer.stub_server }
-
-  let(:stub_registrator) { HttpStub::StubRegistrator.new(stub_server) }
-
-  before(:example) do
-    stub_server.host = server_host
-    stub_server.port = server_port
-    configurer.initialize! if effective_configurer_specification[:initialize]
-  end
-
-  after(:example) { stub_server.reset! }
-
-end

data/spec/support/http_stub/empty_configurer.rb

@@ -1,7 +0,0 @@
-module HttpStub
-
-  class EmptyConfigurer
-    include HttpStub::Configurer
-  end
-
-end

data/spec/support/http_stub/scenario_fixture.rb

@@ -1,33 +0,0 @@
-module HttpStub
-
-  class ScenarioFixture
-
-    def initialize
-      @name                     = "Some Scenario Name"
-      @stub_fixtures            = []
-      @triggered_scenario_names = []
-    end
-
-    def with_name!(name)
-      self.tap { @name = name }
-    end
-
-    def with_stubs!(number)
-      self.tap { @stub_fixtures.concat((1..number).map { HttpStub::StubFixture.new }) }
-    end
-
-    def with_triggered_scenario_names!(names)
-      self.tap { @triggered_scenario_names.concat(names) }
-    end
-
-    def server_payload
-      {
-        "name"                     => @name,
-        "stubs"                    => @stub_fixtures.map(&:server_payload),
-        "triggered_scenario_names" => @triggered_scenario_names
-      }
-    end
-
-  end
-
-end