http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/server/stub/response_spec.rb

@@ -2,46 +2,37 @@ describe HttpStub::Server::Stub::Response do
 
   describe "::create" do
 
-    let(:response_args) { { "body" => body } }
-
-    subject { HttpStub::Server::Stub::Response.create(response_args) }
-
-    context "when the body contains text" do
-
-      let(:body) { "some text" }
-
-      it "creates a text response" do
-        expect(HttpStub::Server::Stub::Response::Text).to receive(:new).with(response_args)
-
-        subject
-      end
-
-      it "returns the created response" do
-        response = instance_double(HttpStub::Server::Stub::Response::Text)
-        allow(HttpStub::Server::Stub::Response::Text).to receive(:new).and_return(response)
-
-        expect(subject).to eql(response)
-      end
-
+    let(:status)           { 201 }
+    let(:headers)          { HttpStub::HeadersFixture.many }
+    let(:body)             { "some text" }
+    let(:delay_in_seconds) { 8 }
+    let(:blocks)           { HttpStub::Server::Stub::Response::BlocksFixture.many }
+    let(:args)             do
+      { status: 201, headers: headers, body: body, delay_in_seconds: delay_in_seconds, blocks: blocks }
     end
 
-    context "when the body contains a file" do
+    let(:primitive_response) { JSON.parse(subject.to_json).symbolize_keys }
 
-      let(:body) { { "file" => { "path" => "a/file.path", "name" => "a_file.name" } } }
+    subject { HttpStub::Server::Stub::Response.create(args) }
 
-      it "creates a file response" do
-        expect(HttpStub::Server::Stub::Response::File).to receive(:new).with(response_args)
+    it "creates a response with the provided status" do
+      expect(primitive_response).to include(status: status)
+    end
 
-        subject
-      end
+    it "creates a response with the provided headers" do
+      expect(primitive_response).to include(headers: headers)
+    end
 
-      it "returns the created response" do
-        response = instance_double(HttpStub::Server::Stub::Response::File)
-        allow(HttpStub::Server::Stub::Response::File).to receive(:new).and_return(response)
+    it "creates a response with the provided body" do
+      expect(primitive_response).to include(body: body)
+    end
 
-        expect(subject).to eql(response)
-      end
+    it "creates a response with the provided delay in seconds" do
+      expect(primitive_response).to include(delay_in_seconds: delay_in_seconds)
+    end
 
+    it "creates a response with the provided blocks" do
+      expect(primitive_response[:blocks]).to eql(blocks.map(&:source))
     end
 
   end

data/spec/lib/http_stub/server/stub/stub_spec.rb

@@ -1,41 +1,37 @@
 describe HttpStub::Server::Stub::Stub do
 
-  let(:base_uri)        { "http://base.uri:8888" }
   let(:stub_id)         { SecureRandom.uuid }
   let(:trigger_payload) do
     {
-      "base_uri" =>   base_uri,
-      "uri" =>        "/a_triggered_path",
-      "method" =>     "post",
-      "headers" =>    { "triggered_header" => "triggered_header_value" },
-      "parameters" => { "triggered_parameter" => "triggered_parameter_value" },
-      "body" =>       { "schema" => { "json" => "trigger schema definition" } },
-      "response" => {
-        "status" => 203,
-        "body" =>   "Triggered body"
+      uri:        "/a_triggered_path",
+      method:     "post",
+      headers:    { trigger_header: "triggered_header_value" },
+      parameters: { trigger_parameter: "triggered_parameter_value" },
+      body:       { schema: { type: "json", definition: "trigger schema definition" } },
+      response:   {
+        status: 203,
+        body:   "triggered body"
       }
     }
   end
-  let(:stub_payload) do
+  let(:stub_payload)    do
     {
-      "id" =>         stub_id,
-      "base_uri" =>   base_uri,
-      "uri" =>        "/a_path",
-      "method" =>     "get",
-      "headers" =>    { "header" => "header value" },
-      "parameters" => { "parameter" => "parameter value" },
-      "body" =>       { "schema" => { "json" => "stub schema definition" } },
-      "response" => {
-        "status" => 201,
-        "body" =>   "Some body"
+      id:         stub_id,
+      uri:        "/a_path",
+      method:     :get,
+      headers:    { header: "header value" },
+      parameters: { parameter: "parameter value" },
+      body:       { schema: { type: :json, definition: "stub schema definition" } },
+      response:   {
+        status: 201,
+        body:   "some body"
       },
-      "triggers" => [ trigger_payload ]
+      triggers:   [ trigger_payload ]
     }
   end
-  let(:match_rules)        { instance_double(HttpStub::Server::Stub::Match::Rules, matches?: true) }
-  let(:response_types)     { [ HttpStub::Server::Stub::Response::Text, HttpStub::Server::Stub::Response::File ] }
-  let(:response)           { instance_double(response_types.sample) }
-  let(:triggers)           { instance_double(HttpStub::Server::Stub::Triggers) }
+  let(:match_rules)     { instance_double(HttpStub::Server::Stub::Match::Rules, matches?: true) }
+  let(:response)        { HttpStub::Server::Stub::ResponseFixture.create }
+  let(:triggers)        { instance_double(HttpStub::Server::Stub::Triggers) }
 
   let(:the_stub) { HttpStub::Server::Stub::Stub.new(stub_payload) }
 
@@ -121,7 +117,7 @@ describe HttpStub::Server::Stub::Stub do
     end
 
     it "returns the response with replaced values" do
-      response_with_replaced_values = instance_double(response_types.sample)
+      response_with_replaced_values = HttpStub::Server::Stub::ResponseFixture.create
       allow(response).to receive(:with_values_from).and_return(response_with_replaced_values)
 
       expect(subject).to eql(response_with_replaced_values)
@@ -129,24 +125,22 @@ describe HttpStub::Server::Stub::Stub do
 
   end
 
-  describe "#uri" do
-
-    subject { the_stub.uri }
+  describe "#stub_id" do
 
-    context "when an id is provided in the payload" do
-
-      it "returns a absolute uri on the server  that includes the id" do
-        expect(subject).to eql("#{base_uri}/http_stub/stubs/#{stub_id}")
-      end
+    subject { the_stub.stub_id }
 
+    it "returns the provided id" do
+      expect(subject).to eql(stub_id)
     end
 
-    context "when an id is not provided in the payload" do
+  end
 
-      it "returns an absolute uri on the server that includes a generated id" do
-        expect(subject).to match(%r{#{base_uri}/http_stub/stubs/[a-zA-Z0-9-]+$})
-      end
+  describe "#uri" do
+
+    subject { the_stub.uri }
 
+    it "returns a relative uri to the stub that includes the id" do
+      expect(subject).to eql("/http_stub/stubs/#{stub_id}")
     end
 
   end

data/spec/lib/http_stub/server/stub/triggers_spec.rb

@@ -2,7 +2,7 @@ describe HttpStub::Server::Stub::Triggers do
 
   let(:scenario_names) { (1..3).map { |i| "Scenario trigger #{i}" } }
   let(:stub_payloads)  { (1..3).map { |i| "Stub trigger payload #{i}" } }
-  let(:args)           { { "scenario_names" => scenario_names, "stubs" => stub_payloads } }
+  let(:args)           { { scenario_names: scenario_names, stubs: stub_payloads } }
 
   let(:stubs) { (1..stub_payloads.length).map { instance_double(HttpStub::Server::Stub::Stub) } }
 
@@ -30,10 +30,24 @@ describe HttpStub::Server::Stub::Triggers do
 
     context "when scenario names are provided" do
 
-      let(:args) { { "scenario_names" => scenario_names } }
+      context "as a symbolised arg" do
+
+        let(:args) { { scenario_names: scenario_names } }
+
+        it "establishes the scenario names" do
+          expect(subject.scenario_names).to eql(scenario_names)
+        end
+
+      end
+
+      context "as a string arg" do
+
+        let(:args) { { "scenario_names" => scenario_names } }
+
+        it "establishes the scenario names" do
+          expect(subject.scenario_names).to eql(scenario_names)
+        end
 
-      it "establishes the scenario names" do
-        expect(subject.scenario_names).to eql(scenario_names)
       end
 
     end
@@ -50,18 +64,39 @@ describe HttpStub::Server::Stub::Triggers do
 
     context "when stubs are provided" do
 
-      let(:args) { { "stubs" => stub_payloads } }
+      context "as a symbolised arg" do
+
+        let(:args) { { stubs: stub_payloads } }
 
-      it "creates a stub for each provided stub payload" do
-        stub_payloads.each { |payload| expect(HttpStub::Server::Stub).to receive(:create).with(payload) }
+        it "creates a stub for each provided stub payload" do
+          stub_payloads.each { |payload| expect(HttpStub::Server::Stub).to receive(:create).with(payload) }
+
+          subject
+        end
+
+        it "estalishes the created stubs" do
+          expect(subject.stubs).to eql(stubs)
+        end
 
-        subject
       end
 
-      it "estalishes the created stubs" do
-        expect(subject.stubs).to eql(stubs)
+      context "as a string arg" do
+
+        let(:args) { { "stubs" => stub_payloads } }
+
+        it "creates a stub for each provided stub payload" do
+          stub_payloads.each { |payload| expect(HttpStub::Server::Stub).to receive(:create).with(payload) }
+
+          subject
+        end
+
+        it "estalishes the created stubs" do
+          expect(subject.stubs).to eql(stubs)
+        end
+
       end
 
+
     end
 
     context "when stubs are not provided" do
@@ -117,10 +152,10 @@ describe HttpStub::Server::Stub::Triggers do
 
     context "when scenario names and stubs are provided" do
 
-      let(:args) { { "scenario_names" => scenario_names, "stubs" => stubs } }
+      let(:args) { { scenario_names: scenario_names, stubs: stubs } }
 
       it "returns a string representation of the arguments provided to the triggers" do
-        expect(subject).to eql(args.to_s)
+        expect(subject).to eql({ "scenario_names" => scenario_names, "stubs" => stubs }.to_s)
       end
 
     end

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

@@ -1,6 +1,6 @@
 describe HttpStub::Server::Stub do
 
-  let(:args) { HttpStub::StubFixture.new.server_payload }
+  let(:args) { HttpStub::Configurator::StubFixture.create_hash }
 
   describe "::create" do
 

data/spec/support/extensions/core/random.rb

@@ -0,0 +1,23 @@
+module HttpStub
+  module Extensions
+
+    module Random
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def string
+          "string #{rand(100_000)}"
+        end
+
+      end
+
+    end
+
+  end
+end
+
+::Random.send(:include, HttpStub::Extensions::Random)

data/spec/support/http_stub/configurator/scenario_builder.rb

@@ -0,0 +1,35 @@
+module HttpStub
+  module Configurator
+
+    class ScenarioBuilder
+
+      def initialize
+        @name                     = "Some Scenario Name"
+        @stub_builders            = []
+        @triggered_scenario_names = []
+      end
+
+      def with_name!(name)
+        self.tap { @name = name }
+      end
+
+      def with_stubs!(number)
+        self.tap { @stub_builders.concat((1..number).map { HttpStub::Configurator::StubBuilder.new }) }
+      end
+
+      def with_triggered_scenario_names!(names)
+        self.tap { @triggered_scenario_names.concat(names) }
+      end
+
+      def build_hash
+        {
+          name:                     @name,
+          stubs:                    @stub_builders.map(&:build_hash),
+          triggered_scenario_names: @triggered_scenario_names
+        }
+      end
+
+    end
+
+  end
+end

data/spec/support/http_stub/configurator/scenario_fixture.rb

@@ -0,0 +1,39 @@
+module HttpStub
+  module Configurator
+
+    class ScenarioFixture
+
+      class << self
+
+        def create_hash(args={})
+          hash = { activated: false, stubs: [], triggered_scenario_names: [] }.merge(args)
+          hash[:name] ||= next_name
+          hash
+        end
+
+        def create(args={})
+          hash = self.create_hash(args)
+          HttpStub::Configurator::Scenario.new(hash[:name], nil).tap do |scenario|
+            scenario.add_stubs!(hash[:stubs])
+            scenario.activate_scenarios!(hash[:triggered_scenario_names])
+            scenario.activate! if hash[:activated]
+          end
+        end
+
+        def many
+          (1..3).map { self.create }
+        end
+
+        private
+
+        def next_name
+          @next_id ||= 0
+          "scenario #{@next_id += 1}"
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/support/http_stub/configurator/stub_builder.rb

@@ -0,0 +1,112 @@
+module HttpStub
+  module Configurator
+
+    class StubBuilder
+
+      attr_reader :match_rules, :response, :triggers
+
+      class Part
+
+        attr_writer :hash
+
+        def initialize(hash)
+          @hash = hash.with_indifferent_access
+        end
+
+        def merge!(options)
+          @hash.merge!(options)
+        end
+
+        def http_method
+          @hash[:method]
+        end
+
+        def to_hash
+          @hash
+        end
+
+        def method_missing(name, *args)
+          if name.to_s.end_with?("=")
+            attribute_name = name.to_s[0..-2].to_sym
+            @hash[attribute_name] = args.first
+          else
+            @hash[name]
+          end
+        end
+
+      end
+
+      def initialize
+        @unique_value = SecureRandom.uuid
+        @match_rules = HttpStub::Configurator::StubBuilder::Part.new(
+          uri:        "/stub/uri/#{@unique_value}",
+          method:     "some #{@unique_value} method",
+          headers:    { "request_header_name" => "request header value #{@unique_value}" },
+          parameters: { "parameter_name" => "parameter value #{@unique_value}" },
+          body:       "some body"
+        )
+        @response = HttpStub::Configurator::StubBuilder::Part.new(
+          status:           500,
+          headers:          { "response_header_name" => "response header value #{@unique_value}" },
+          body:             "body #{@unique_value}",
+          delay_in_seconds: 8,
+          blocks:           []
+        )
+        @triggers = {
+          scenarios: [],
+          stubs:     []
+        }
+      end
+
+      def match_rules=(options)
+        self.tap { @match_rules.hash = options }
+      end
+
+      def response=(options)
+        self.tap { @response.hash = options }
+      end
+
+      def with_response!(options)
+        self.tap { @response.merge!(options) }
+      end
+
+      def with_response_block!
+        block = lambda do |request|
+          { headers: { header_name: "header value #{request.headers[:some_header]}" } }
+        end
+        with_response!(blocks: [ block ])
+      end
+
+      def with_text_response!
+        with_response!(body: "payload #{@unique_value} text response")
+      end
+
+      def with_file_response!
+        with_response!(body: { file: { path: "payload/#{@unique_value}/file.path",
+                                       name: "payload_#{@unique_value}_file.name" } })
+      end
+
+      def with_triggered_scenarios!(scenario_names=[ "scenario name", "another scenario name" ])
+        self.tap { @triggers[:scenarios].concat(scenario_names) }
+      end
+
+      def with_triggered_stubs!(stubs=[ HttpStub::Configurator::Stub.create, HttpStub::Configurator::Stub.create ])
+        self.tap { @triggers[:stubs].concat(stubs) }
+      end
+
+      def build_hash
+        build.to_hash
+      end
+
+      def build
+        HttpStub::Configurator::Stub.create do |stub|
+          stub.match_requests(@match_rules.to_hash)
+          stub.respond_with(@response.to_hash)
+          stub.trigger(@triggers)
+        end
+      end
+
+    end
+
+  end
+end