http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/{configurer/dsl/stub_builder_template_spec.rb → configurator/stub/template_spec.rb}

@@ -1,4 +1,4 @@
-describe HttpStub::Configurer::DSL::StubBuilderTemplate do
+describe HttpStub::Configurator::Stub::Template do
 
   let(:parent_uri)             { "/some/parent/uri" }
   let(:parent_template)        do
@@ -10,31 +10,31 @@ describe HttpStub::Configurer::DSL::StubBuilderTemplate do
   let(:initial_request_method) { :put }
   let(:initial_block)          { lambda { |stub| stub.match_requests(method: initial_request_method) } }
 
-  let(:stub_builder_template) { described_class.new }
+  let(:template) { described_class.new }
 
-  shared_context "mocked stub builder" do
+  shared_context "mocked stub" do
 
-    let(:stub_builder) { instance_double(HttpStub::Configurer::DSL::StubBuilder) }
+    let(:templates_stub) { instance_double(HttpStub::Configurator::Stub::Stub) }
 
-    before(:example) { allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new).and_return(stub_builder) }
+    before(:example) { allow(HttpStub::Configurator::Stub::Stub).to receive(:new).and_return(templates_stub) }
 
   end
 
-  it "creates a stub builder to hold values established on the template" do
-    allow(HttpStub::Configurer::DSL::StubBuilder).to receive(:new)
+  it "creates a stub to hold values established on the template" do
+    allow(HttpStub::Configurator::Stub::Stub).to receive(:new)
 
-    stub_builder_template
+    template
   end
 
   describe "#match_requests" do
-    include_context "mocked stub builder"
+    include_context "mocked stub"
 
     let(:request_matching_rules) { { uri: "/some/stub/uri", method: :get } }
 
-    subject { stub_builder_template.match_requests(request_matching_rules) }
+    subject { template.match_requests(request_matching_rules) }
 
-    it "delegates to the templates stub builder" do
-      expect(stub_builder).to receive(:match_requests).with(request_matching_rules)
+    it "delegates to the templates stub" do
+      expect(templates_stub).to receive(:match_requests).with(request_matching_rules)
 
       subject
     end
@@ -42,22 +42,22 @@ describe HttpStub::Configurer::DSL::StubBuilderTemplate do
   end
 
   describe "#schema" do
-    include_context "mocked stub builder"
+    include_context "mocked stub"
 
     let(:type)       { :some_schema_type }
     let(:definition) { "some schema definition" }
 
-    subject { stub_builder_template.schema(type, definition) }
+    subject { template.schema(type, definition) }
 
-    it "delegates to the templates stub builder" do
-      expect(stub_builder).to receive(:schema).with(type, definition)
+    it "delegates to the templates stub" do
+      expect(templates_stub).to receive(:schema).with(type, definition)
 
       subject
     end
 
     it "returns the created schema" do
       schema = { schema: :some_schema }
-      expect(stub_builder).to receive(:schema).and_return(schema)
+      expect(templates_stub).to receive(:schema).and_return(schema)
 
       expect(subject).to eql(schema)
     end
@@ -65,14 +65,14 @@ describe HttpStub::Configurer::DSL::StubBuilderTemplate do
   end
 
   describe "#respond_with" do
-    include_context "mocked stub builder"
+    include_context "mocked stub"
 
     let(:response_settings) { { status: 204 } }
 
-    subject { stub_builder_template.respond_with(response_settings) }
+    subject { template.respond_with(response_settings) }
 
-    it "delegates to the templates stub builder" do
-      expect(stub_builder).to receive(:respond_with).with(response_settings)
+    it "delegates to the templates stub" do
+      expect(templates_stub).to receive(:respond_with).with(response_settings)
 
       subject
     end
@@ -80,14 +80,14 @@ describe HttpStub::Configurer::DSL::StubBuilderTemplate do
   end
 
   describe "#trigger" do
-    include_context "mocked stub builder"
+    include_context "mocked stub"
 
     let(:trigger_settings) { { scenario: "some scenario name" } }
 
-    subject { stub_builder_template.trigger(trigger_settings) }
+    subject { template.trigger(trigger_settings) }
 
-    it "delegates to the templates stub builder" do
-      expect(stub_builder).to receive(:trigger).with(trigger_settings)
+    it "delegates to the templates stub" do
+      expect(templates_stub).to receive(:trigger).with(trigger_settings)
 
       subject
     end
@@ -95,7 +95,7 @@ describe HttpStub::Configurer::DSL::StubBuilderTemplate do
   end
 
   describe "#invoke" do
-    include_context "mocked stub builder"
+    include_context "mocked stub"
 
     let(:block_verifier) { double("BlockVerifier") }
     let(:block)          do
@@ -105,16 +105,16 @@ describe HttpStub::Configurer::DSL::StubBuilderTemplate do
       end
     end
 
-    let(:stub_builder) { HttpStub::Configurer::DSL::StubBuilder.new }
+    let(:templates_stub) { HttpStub::Configurator::Stub::Stub.new }
 
-    subject { stub_builder_template.invoke(&block) }
+    subject { template.invoke(&block) }
 
     it "invokes the block with the templates stub builder" do
       expect(block_verifier).to receive(:verify)
 
       subject
 
-      expect(@yielded_stub).to eql(stub_builder)
+      expect(@yielded_stub).to eql(templates_stub)
     end
 
   end
@@ -130,70 +130,72 @@ describe HttpStub::Configurer::DSL::StubBuilderTemplate do
       end
     end
 
-    let(:stub_builder_template) { described_class.new(parent_template) }
+    let(:template) { described_class.new(parent_template) }
+
+    let(:built_stub_hash) { subject.to_hash }
 
-    subject { stub_builder_template.build_stub }
+    subject { template.build_stub }
 
     context "when a parent template had been provided" do
 
       it "creates a stub capable of containing values established in the parent template" do
-        expect(subject.request[:uri]).to eql(parent_uri)
+        expect(built_stub_hash[:match_rules][:uri]).to eql(parent_uri)
       end
 
     end
 
     context "when an initial block had been provided" do
 
-      let(:stub_builder_template) { described_class.new(&initial_block) }
+      let(:template) { described_class.new(&initial_block) }
 
       it "creates a stub capable of containing values established in the initial block" do
-        expect(subject.request[:method]).to eql(initial_request_method)
+        expect(built_stub_hash[:match_rules][:method]).to eql(initial_request_method)
       end
 
     end
 
     context "when response overrides are provided upon building the stub" do
 
-      subject { stub_builder_template.build_stub(response_overrides) }
+      subject { template.build_stub(response_overrides) }
 
       it "creates a stub containing the overrides" do
-        expect(subject.response[:status]).to eql(201)
+        expect(built_stub_hash[:response][:status]).to eql(201)
       end
 
       it "overrides any values initially established" do
-        expect(subject.response[:body]).to eql("response overrides body")
+        expect(built_stub_hash[:response][:body]).to eql("response overrides body")
       end
 
     end
 
     context "when a block is provided upon building the stub" do
 
-      subject { stub_builder_template.build_stub(&block) }
+      subject { template.build_stub(&block) }
 
       it "creates a stub that is modified by the block" do
-        expect(subject.request[:uri]).to eql("/some/block/uri")
+        expect(built_stub_hash[:match_rules][:uri]).to eql("/some/block/uri")
       end
 
       it "overrides any values initially established" do
-        expect(subject.response[:body]).to eql("block body")
+        expect(built_stub_hash[:response][:body]).to eql("block body")
       end
 
     end
 
     context "when both response overrides and a block are provided" do
 
-      subject { stub_builder_template.build_stub(response_overrides, &block) }
+      subject { template.build_stub(response_overrides, &block) }
 
       it "creates a stub containing response overrides" do
-        expect(subject.response[:status]).to eql(201)
+        expect(built_stub_hash[:response][:status]).to eql(201)
       end
 
       it "creates a stub that is modified by the block" do
-        expect(subject.request[:uri]).to eql("/some/block/uri")
+        expect(built_stub_hash[:match_rules][:uri]).to eql("/some/block/uri")
       end
 
       it "creates a stub with values established in the block taking precedence over response overrides" do
-        expect(subject.response[:body]).to eql("block body")
+        expect(built_stub_hash[:response][:body]).to eql("block body")
       end
 
     end

data/spec/lib/http_stub/configurator/stub_spec.rb

@@ -0,0 +1,27 @@
+describe HttpStub::Configurator::Stub do
+
+  describe "::create" do
+
+    let(:name)           { "some stub name" }
+    let(:block_verifier) { double("BlockVerifier") }
+    let(:block)          { lambda { block_verifier.verify } }
+
+    subject { described_class.create(name, &block) }
+
+    it "creates a stub with the provided arguments" do
+      expect(HttpStub::Configurator::Stub::Stub).to receive(:new).with(name).and_yield
+      expect(block_verifier).to receive(:verify)
+
+      subject
+    end
+
+    it "returns the created stub" do
+      created_stub = instance_double(HttpStub::Configurator::Stub::Stub)
+      allow(HttpStub::Configurator::Stub::Stub).to receive(:new).and_return(created_stub)
+
+      expect(subject).to eql(created_stub)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/configurator_spec.rb

@@ -0,0 +1,113 @@
+describe HttpStub::Configurator do
+
+  let(:configurator_class) { Class.new { include HttpStub::Configurator } }
+  let(:configurator)       { configurator_class.new }
+
+  describe "::state" do
+
+    subject { configurator_class.state }
+
+    it "creates state for the configurator" do
+      expect(HttpStub::Configurator::State).to receive(:new)
+
+      subject
+    end
+
+    it "returns the created state" do
+      state = HttpStub::Configurator::State.new
+      allow(HttpStub::Configurator::State).to receive(:new).and_return(state)
+
+      expect(subject).to eql(state)
+    end
+
+    it "reuses the state in subsequent requests" do
+      expect(subject).to be(configurator_class.state)
+    end
+
+  end
+
+  describe "::stub_server" do
+
+    subject { configurator_class.stub_server }
+
+    it "creates a server" do
+      expect(HttpStub::Configurator::Server).to receive(:new)
+
+      subject
+    end
+
+    it "returns the created server" do
+      server = instance_double(HttpStub::Configurator::Server)
+      allow(HttpStub::Configurator::Server).to receive(:new).and_return(server)
+
+      expect(subject).to eql(server)
+    end
+
+    it "reuses the stub server in subsequent requests" do
+      expect(subject).to be(configurator_class.stub_server)
+    end
+
+  end
+
+  describe "::parts=" do
+
+    class HttpStub::Configurator::TestablePart
+      include HttpStub::Configurator::Part
+
+      attr_reader :configurator_class
+
+      def apply_to(configurator_class)
+        @configurator_class = configurator_class
+      end
+
+    end
+
+    let(:parts) { (1..3).map { HttpStub::Configurator::TestablePart.new } }
+
+    subject do
+      configurator_class.parts = { part_1: parts[0], part_2: parts[1], part_3: parts[2] }
+    end
+
+    it "allows each part to be accessed on the configurator by name" do
+      subject
+
+      parts_on_configurator = [ configurator.part_1, configurator.part_2, configurator.part_3 ]
+      expect(parts_on_configurator).to eql(parts)
+    end
+
+    it "allows each part to be accessed on the configurator class by name" do
+      subject
+
+      parts_on_configurator_class = [ configurator_class.part_1, configurator_class.part_2, configurator_class.part_3 ]
+      expect(parts_on_configurator_class).to eql(parts)
+    end
+
+    it "applies the parts to the configurator" do
+      subject
+
+      expect(parts.map(&:configurator_class)).to eql([ configurator_class ] * 3)
+    end
+
+  end
+
+  describe "#state" do
+
+    subject { configurator.state }
+
+    it "returns the same state as the class method" do
+      expect(subject).to be(configurator_class.state)
+    end
+
+  end
+
+  describe "#stub_server" do
+
+    subject { configurator.stub_server }
+
+    it "returns the same server as the class method" do
+      expect(subject).to be(configurator_class.stub_server)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/extensions/core/hash_spec.rb

@@ -4,9 +4,9 @@ describe HttpStub::Extensions::Core::Hash do
 
     subject { hash.underscore_keys }
 
-    describe "when the hash contains keys which are strings" do
+    context "when the hash contains keys which are strings" do
 
-      describe "and keys contain underscores and hyphens" do
+      context "and keys contain underscores and hyphens" do
 
         let(:hash) do
           { "has_underscore" => 1, "has-hypen" => 2, "has_underscore_and-hypen" => 3 }
@@ -20,7 +20,7 @@ describe HttpStub::Extensions::Core::Hash do
 
     end
 
-    describe "when the hash contains keys which are not strings" do
+    context "when the hash contains keys which are not strings" do
 
       let(:hash) do
         { 1 => 2, :symbol => 3, nil => 4 }

data/spec/lib/http_stub/extensions/core/object_spec.rb

@@ -0,0 +1,29 @@
+describe HttpStub::Extensions::Core::Object do
+
+  it "patches ::Object" do
+    expect(::Object.included_modules).to include(described_class)
+  end
+
+  describe "#short_class_name" do
+
+    subject { object.short_class_name }
+
+    context "when a class name is a single word" do
+
+      it "returns the name in lower case" do
+        
+      end
+
+    end
+
+    context "when a class name contains many words" do
+
+      it "combines the words with an underscore" do
+        
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/http_stub/rake/server_daemon_tasks_smoke_spec.rb

@@ -1,27 +1,32 @@
 describe HttpStub::Rake::ServerDaemonTasks do
+  include_context "surpressed output"
   include Rake::DSL
 
-  before(:context) { HttpStub::Rake::ServerDaemonTasks.new(name: :example_server_daemon, port: 8002) }
+  before(:context) do
+    @server_name_in_rakefile = :example_server_daemon
+    @port_in_rakefile        = 8001
+    HttpStub::Rake::ServerDaemonTasks.new(
+      name:         @server_name_in_rakefile,
+      configurator: HttpStub::ConfiguratorFixture.create(port: @port_in_rakefile)
+    )
+  end
 
   describe "start task" do
 
     context "when invoked" do
 
-      before(:context) { @exit_flag = Rake::Task["example_server_daemon:start"].invoke("--trace") }
+      before(:context) { @exit_flag = system "rake #{@server_name_in_rakefile}:start > /dev/null" }
 
-      after(:context) { Rake::Task["example_server_daemon:stop"].invoke("--trace") }
+      after(:context) { system "rake #{@server_name_in_rakefile}:stop > /dev/null" }
 
       it "exits with a status code of 0" do
-        expect(@exit_flag).to be_truthy
+        expect(@exit_flag).to be(true)
       end
 
       it "starts a stub server that responds to stub requests" do
-        request = Net::HTTP::Post.new("/http_stub/stubs")
-        request.body = { response: { status: 302, body: "Some Body" } }.to_json
-
-        response = Net::HTTP.new("localhost", 8002).start { |http| http.request(request) }
+        response = HTTParty.get("http://localhost:#{@port_in_rakefile}/http_stub/stubs")
 
-        expect(response.code).to eql("200")
+        expect(response.code).to eql(200)
       end
 
     end