http_stub 0.13.5 → 0.14.0.rc1

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

@@ -15,28 +15,43 @@ describe HttpStub::Models::Stub do
     }
   end
   let(:stub_method) { "get" }
+  let(:stub_trigger) do
+    {
+      "uri" =>        "/a_triggered_path",
+      "method" =>     "post",
+      "headers" =>    { "triggered_header" => "triggered_header_value" },
+      "parameters" => { "triggered_parameter" => "triggered_parameter_value" },
+      "response" => {
+        "status" => 203,
+        "body" =>   "Triggered body"
+      }
+    }
+  end
   let(:stub_args) do
     {
-      "uri" => "/a_path",
-      "method" => stub_method,
-      "headers" => raw_stub_headers,
+      "uri" =>        "/a_path",
+      "method" =>     stub_method,
+      "headers" =>    raw_stub_headers,
       "parameters" => raw_stub_parameters,
       "response" => {
         "status" => 201,
-        "body" => "Foo"
-      }
+        "body" =>   "Some body"
+      },
+      "triggers" => [ stub_trigger ]
     }
   end
-  let(:stub_uri) { double(HttpStub::Models::StubUri, match?: true) }
-  let(:stub_parameters) { double(HttpStub::Models::StubParameters, match?: true) }
-  let(:stub_headers) { double(HttpStub::Models::StubHeaders, match?: true) }
+  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(:the_stub) { HttpStub::Models::Stub.new(stub_args) }
 
-  before(:each) do
-    HttpStub::Models::StubUri.stub(:new).and_return(stub_uri)
-    HttpStub::Models::StubParameters.stub(:new).and_return(stub_parameters)
-    HttpStub::Models::StubHeaders.stub(:new).and_return(stub_headers)
+  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)
   end
 
   describe "#satisfies?" do
@@ -47,7 +62,7 @@ describe HttpStub::Models::Stub do
 
     describe "when the request uri matches" do
 
-      before(:each) { stub_uri.stub(:match?).with(request).and_return(true) }
+      before(:example) { allow(stub_uri).to receive(:match?).with(request).and_return(true) }
 
       describe "and the request method matches" do
 
@@ -55,16 +70,16 @@ describe HttpStub::Models::Stub do
 
           describe "that matches" do
 
-            before(:each) { stub_headers.stub(:match?).with(request).and_return(true) }
+            before(:example) { allow(stub_headers).to receive(:match?).with(request).and_return(true) }
 
             describe "and a parameter match is configured" do
 
               describe "that matches" do
 
-                before(:each) { stub_parameters.stub(:match?).with(request).and_return(true) }
+                before(:example) { allow(stub_parameters).to receive(:match?).with(request).and_return(true) }
 
-                it "should return true" do
-                  the_stub.satisfies?(request).should be_true
+                it "returns true" do
+                  expect(the_stub.satisfies?(request)).to be_truthy
                 end
 
               end
@@ -81,10 +96,10 @@ describe HttpStub::Models::Stub do
 
     describe "when the request uri does not match" do
 
-      before(:each) { stub_uri.stub(:match?).with(request).and_return(false) }
+      before(:example) { allow(stub_uri).to receive(:match?).with(request).and_return(false) }
 
-      it "should return false" do
-        the_stub.satisfies?(request).should be_false
+      it "returns false" do
+        expect(the_stub.satisfies?(request)).to be_falsey
       end
 
     end
@@ -93,28 +108,28 @@ describe HttpStub::Models::Stub do
 
       let(:request_method) { "post" }
 
-      it "should return false" do
-        the_stub.satisfies?(request).should be_false
+      it "returns false" do
+        expect(the_stub.satisfies?(request)).to be_falsey
       end
 
     end
 
     describe "when the headers do not match" do
 
-      before(:each) { stub_headers.stub(:match?).with(request).and_return(false) }
+      before(:example) { allow(stub_headers).to receive(:match?).with(request).and_return(false) }
 
-      it "should return false" do
-        the_stub.satisfies?(request).should be_false
+      it "returns false" do
+        expect(the_stub.satisfies?(request)).to be_falsey
       end
 
     end
 
     describe "when the parameters do not match" do
 
-      before(:each) { stub_parameters.stub(:match?).with(request).and_return(false) }
+      before(:example) { allow(stub_parameters).to receive(:match?).with(request).and_return(false) }
 
-      it "should return false" do
-        the_stub.satisfies?(request).should be_false
+      it "returns false" do
+        expect(the_stub.satisfies?(request)).to be_falsey
       end
 
     end
@@ -123,55 +138,64 @@ describe HttpStub::Models::Stub do
 
   describe "#uri" do
 
-    it "should return the parameters model encapsulating the uri provided in the request body" do
-      the_stub.uri.should eql(stub_uri)
+    it "returns the parameters model encapsulating the uri provided in the request body" do
+      expect(the_stub.uri).to eql(stub_uri)
     end
 
   end
 
   describe "#method" do
 
-    it "should return the value provided in the request body" do
-      the_stub.method.should eql(stub_method)
+    it "returns the value provided in the request body" do
+      expect(the_stub.method).to eql(stub_method)
     end
 
   end
 
   describe "#headers" do
 
-    it "should return the headers model encapsulating the headers provided in the request body" do
-      the_stub.headers.should eql(stub_headers)
+    it "returns the headers model encapsulating the headers provided in the request body" do
+      expect(the_stub.headers).to eql(stub_headers)
     end
 
   end
 
   describe "#parameters" do
 
-    it "should return the parameters model encapsulating the parameters provided in the request body" do
-      the_stub.parameters.should eql(stub_parameters)
+    it "returns the parameters model encapsulating the parameters provided in the request body" do
+      expect(the_stub.parameters).to eql(stub_parameters)
     end
 
   end
 
   describe "#response" do
 
-    it "should expose the provided response status" do
-      the_stub.response.status.should eql(201)
+    it "exposes the provided response status" do
+      expect(the_stub.response.status).to eql(201)
     end
 
-    it "should expose the provided response body" do
-      the_stub.response.body.should eql("Foo")
+    it "exposes the provided response body" do
+      expect(the_stub.response.body).to eql("Some body")
+    end
+
+  end
+
+  describe "#triggers" do
+
+    it "returns the triggers model encapsulating the triggers provided in the request body" do
+      expect(the_stub.triggers).to eql(stub_triggers)
     end
 
   end
 
   describe "#to_s" do
 
-    it "should return a string representation of the stub arguments" do
-      stub_args.should_receive(:to_s).and_return("stub arguments string")
+    it "returns a string representation of the stub arguments" do
+      expect(stub_args).to receive(:to_s).and_return("stub arguments string")
 
-      the_stub.to_s.should eql("stub arguments string")
+      expect(the_stub.to_s).to eql("stub arguments string")
     end
+
   end
 
 end

data/spec/lib/http_stub/models/stub_triggers_spec.rb

@@ -0,0 +1,64 @@
+describe HttpStub::Models::StubTriggers do
+
+  let(:trigger_bodies)     { (1..3).map { |i| "trigger body #{i}" } }
+  let(:stubs_for_triggers) { (1..trigger_bodies.length).map { instance_double(HttpStub::Models::Stub) } }
+  let(:stub_triggers)      { HttpStub::Models::StubTriggers.new(trigger_bodies) }
+
+  before(:example) do
+    allow(HttpStub::Models::Stub).to receive(:new).and_return(*stubs_for_triggers)
+  end
+
+  describe "constructor" do
+
+    it "creates a stub for each provided trigger" do
+      trigger_bodies.zip(stubs_for_triggers).each do |body, stub|
+        expect(HttpStub::Models::Stub).to receive(:new).with(body).and_return(stub)
+      end
+
+      stub_triggers
+    end
+
+  end
+
+  describe "#add_to" do
+
+    let(:registry) { instance_double(HttpStub::Models::StubRegistry) }
+    let(:request)  { instance_double("HttpRequest") }
+
+    it "adds each stub to the provided registry" do
+      stubs_for_triggers.each { |stub_for_trigger| expect(registry).to receive(:add).with(stub_for_trigger, request) }
+
+      stub_triggers.add_to(registry, request)
+    end
+
+  end
+
+  describe "#to_s" do
+
+    let(:trigger_strings) { (1..stubs_for_triggers.length).map { |i| "trigger string ##{i}" } }
+
+    before(:example) do
+      stubs_for_triggers.zip(trigger_strings).each do |stub_for_trigger, string|
+        allow(stub_for_trigger).to receive(:to_s).and_return(string)
+      end
+    end
+
+    it "should contain a string representation of each trigger" do
+      result = stub_triggers.to_s
+
+      trigger_strings.each { |trigger_string| expect(result).to include(trigger_string) }
+    end
+
+  end
+
+  describe "#each" do
+
+    it "yields to the stubs for each trigger" do
+      yielded_stubs = stub_triggers.each.map.to_a
+
+      expect(yielded_stubs).to eql(stubs_for_triggers)
+    end
+
+  end
+
+end

data/spec/lib/http_stub/models/stub_uri_spec.rb

@@ -5,12 +5,12 @@ describe HttpStub::Models::StubUri do
   let(:value_matcher) { double(HttpStub::Models::StringValueMatcher).as_null_object }
   let(:stub_uri) { HttpStub::Models::StubUri.new(stubbed_uri) }
 
-  before(:each) { HttpStub::Models::StringValueMatcher.stub(:new).and_return(value_matcher) }
+  before(:example) { allow(HttpStub::Models::StringValueMatcher).to receive(:new).and_return(value_matcher) }
 
   describe "constructor" do
 
-    it "should create a value matcher for the provided uri" do
-      HttpStub::Models::StringValueMatcher.should_receive(:new).with(stubbed_uri)
+    it "creates a value matcher for the provided uri" do
+      expect(HttpStub::Models::StringValueMatcher).to receive(:new).with(stubbed_uri)
 
       stub_uri
     end
@@ -21,20 +21,20 @@ describe HttpStub::Models::StubUri do
 
     let(:request_uri) { "/some/uri" }
 
-    it "should delegate to the value matcher representation of the provided uri" do
-      value_matcher.should_receive(:match?).with(request_uri).and_return(true)
+    it "delegates to the value matcher representation of the provided uri" do
+      expect(value_matcher).to receive(:match?).with(request_uri).and_return(true)
 
-      stub_uri.match?(request).should be_true
+      expect(stub_uri.match?(request)).to be_truthy
     end
 
   end
 
   describe "#to_s" do
 
-    it "should delegate to the value matcher representation of the provided uri" do
-      value_matcher.should_receive(:to_s).and_return("some value matcher string")
+    it "delegates to the value matcher representation of the provided uri" do
+      expect(value_matcher).to receive(:to_s).and_return("some value matcher string")
 
-      stub_uri.to_s.should eql("some value matcher string")
+      expect(stub_uri.to_s).to eql("some value matcher string")
     end
 
   end

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

@@ -1,27 +1,27 @@
 describe HttpStub::Rake::ServerDaemonTasks do
   include Rake::DSL
 
-  before(:all) { HttpStub::Rake::ServerDaemonTasks.new(name: :example_server_daemon, port: 8002) }
+  before(:context) { HttpStub::Rake::ServerDaemonTasks.new(name: :example_server_daemon, port: 8002) }
 
   describe "start task" do
 
     context "when invoked" do
 
-      before(:all) { @exit_flag = Rake::Task["example_server_daemon:start"].invoke("--trace") }
+      before(:context) { @exit_flag = Rake::Task["example_server_daemon:start"].invoke("--trace") }
 
-      after(:all) { Rake::Task["example_server_daemon:stop"].invoke("--trace") }
+      after(:context) { Rake::Task["example_server_daemon:stop"].invoke("--trace") }
 
-      it "should exit with a status code of 0" do
-        @exit_flag.should be_true
+      it "exits with a status code of 0" do
+        expect(@exit_flag).to be_truthy
       end
 
-      it "should start a stub server that responds to stub requests" do
+      it "starts a stub server that responds to stub requests" do
         request = Net::HTTP::Post.new("/stubs")
         request.body = { "response" => { "status" => 302, "body" => "Some Body" } }.to_json
 
         response = Net::HTTP.new("localhost", 8002).start { |http| http.request(request) }
 
-        response.code.should eql("200")
+        expect(response.code).to eql("200")
       end
 
     end

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

@@ -1,26 +1,26 @@
 describe HttpStub::Rake::ServerTasks do
   include Rake::DSL
 
-  before(:all) { HttpStub::Rake::ServerTasks.new(name: :test_server, port: 8003) }
+  before(:context) { HttpStub::Rake::ServerTasks.new(name: :test_server, port: 8003) }
 
   describe "start task" do
 
     context "when invoked" do
 
-      before(:all) do
+      before(:context) do
         @server_thread = Thread.new { Rake::Task["test_server:start:foreground"].invoke("--trace") }
         ::Wait.until!("http stub server started") { Net::HTTP.get_response("localhost", "/", 8003) }
       end
 
-      after(:all) { @server_thread.kill }
+      after(:context) { @server_thread.kill }
 
-      it "should start a stub server that responds to stub requests" do
+      it "starts a stub server that responds to stub requests" do
         request = Net::HTTP::Post.new("/stubs")
         request.body = { "response" => { "status" => 302, "body" => "Some Body" } }.to_json
 
         response = Net::HTTP.new("localhost", 8003).start { |http| http.request(request) }
 
-        response.code.should eql("200")
+        expect(response.code).to eql("200")
       end
 
     end

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

@@ -1,28 +1,33 @@
 describe HttpStub::Rake::ServerTasks do
 
-  let(:default_args) { { port: 8001 } }
+  class HttpStub::Rake::ServerTasksTestCounter
+
+    def self.next
+      @counter ||= 0
+      @counter += 1
+    end
+
+  end
+
+  let(:server_name)  { "server_tasks_test_#{HttpStub::Rake::ServerTasksTestCounter.next}".to_sym }
+  let(:default_args) { { port: 8001, name: server_name } }
+  let(:args)         { {} }
   let(:configurer)   { double(HttpStub::Configurer).as_null_object }
 
-  before(:each) { HttpStub::Rake::ServerTasks.new(default_args.merge(args)) }
+  before(:example) { HttpStub::Rake::ServerTasks.new(default_args.merge(args)) }
 
   describe "the configure task" do
 
     context "when a configurer is provided" do
 
-      let(:args) { { name: :configure_task_configurer_provided_test, configurer: configurer } }
+      let(:args) { { configurer: configurer } }
 
       context "and the task is executed" do
 
         it "initializes the provided configurer" do
-          configurer.should_receive(:initialize!)
+          expect(configurer).to receive(:initialize!)
 
-          Rake::Task["configure_task_configurer_provided_test:configure"].execute
-        end
-
-        it "resets the provided configurer to ensure stubs are in their initial state" do
-          configurer.should_receive(:reset!)
-
-          Rake::Task["configure_task_configurer_provided_test:configure"].execute
+          Rake::Task["#{server_name}:configure"].execute
         end
 
       end
@@ -31,11 +36,8 @@ describe HttpStub::Rake::ServerTasks do
 
     context "when a configurer is not provided" do
 
-      let(:args) { { name: :configure_task_configurer_not_provided_test } }
-
       it "does not generate a task" do
-        lambda { Rake::Task["configure_task_configurer_not_provided_test:configure"] }.should
-          raise_error(/Don't know how to build task/)
+        expect { Rake::Task["#{server_name}:configure"] }.to raise_error(/Don't know how to build task/)
       end
 
     end