http_stub 0.27.0 → 0.28.0.beta1

data/spec/lib/http_stub/server/stub/match/controller_spec.rb

@@ -43,13 +43,13 @@ describe HttpStub::Server::Stub::Match::Controller do
       before(:example) { allow(session).to receive(:last_match).and_return(match) }
 
       it "creates an ok response containing the JSON representation of the match" do
-        expect(HttpStub::Server::Response).to receive(:ok).with("body" => match_json)
+        expect(HttpStub::Server::Response).to receive(:ok).with(body: match_json)
 
         subject
       end
 
       it "returns the response" do
-        response = instance_double(HttpStub::Server::Stub::Response::Text)
+        response = HttpStub::Server::Stub::ResponseFixture.create
         allow(HttpStub::Server::Response).to receive(:ok).and_return(response)
 
         expect(subject).to eql(response)

data/spec/lib/http_stub/server/stub/match/exact_value_matcher_spec.rb

@@ -2,30 +2,68 @@ describe HttpStub::Server::Stub::Match::ExactValueMatcher do
 
   describe "::match?" do
 
-    let(:stub_value) { "some stub value" }
+    let(:actual_value) { "some actual value" }
 
-    describe "when the stub value is equal to the actual value" do
+    subject { described_class.match?(stub_value, actual_value) }
 
-      let(:actual_value) { stub_value }
+    context "when the stub value is a string" do
+
+      context "and the stub value is equal to the actual value" do
+
+        let(:stub_value) { actual_value }
+
+        it "returns true" do
+          expect(subject).to be(true)
+        end
+
+      end
+
+      context "and the stub value is not equal to the actual value" do
+
+        let(:stub_value) { "some other value" }
+
+        it "returns false" do
+          expect(subject).to be(false)
+        end
 
-      it "returns true" do
-        expect(perform_match).to be_truthy
       end
 
     end
 
-    describe "when the stub value is not equal to the actual value" do
+    context "when the stub value is an integer" do
 
-      let(:actual_value) { "not equal to stub value" }
+      let(:stub_value) { 88 }
+
+      context "whose string representation is equal to the actual value" do
+
+        let(:actual_value) { "88" }
+
+        it "returns true" do
+          expect(subject).to be(true)
+        end
+
+      end
+
+      context "whose string representation is not equal to the actual value" do
+
+        let(:actual_value) { "89" }
+
+        it "returns false" do
+          expect(subject).to be(false)
+        end
 
-      it "returns false" do
-        expect(perform_match).to be_falsey
       end
 
     end
 
-    def perform_match
-      HttpStub::Server::Stub::Match::ExactValueMatcher.match?(stub_value, actual_value)
+    context "when the stub value is another type" do
+
+      let(:stub_value) { actual_value.to_sym }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
     end
 
   end

data/spec/lib/http_stub/server/stub/match/hash_matcher_spec.rb

@@ -11,7 +11,7 @@ describe HttpStub::Server::Stub::Match::HashMatcher do
     let(:actual_hash) { {} }
 
     subject { described_class.match?(stub_hash, actual_hash) }
-    
+
     context "when the stub hash contains multiple entries" do
 
       it "returns the result of evaluating a match for each stub value" do
@@ -114,9 +114,9 @@ describe HttpStub::Server::Stub::Match::HashMatcher do
         end
 
       end
-      
+
     end
-    
+
   end
-  
+
 end

data/spec/lib/http_stub/server/stub/match/match_spec.rb

@@ -1,10 +1,10 @@
 describe HttpStub::Server::Stub::Match::Match do
 
-  let(:request)  { instance_double(HttpStub::Server::Request::Request) }
-  let(:response) { instance_double(HttpStub::Server::Stub::Response::Base) }
-  let(:stub)     { instance_double(HttpStub::Server::Stub::Stub) }
+  let(:request)  { HttpStub::Server::RequestFixture.create }
+  let(:response) { HttpStub::Server::Stub::ResponseFixture.create }
+  let(:stub)     { HttpStub::Server::StubFixture.create }
 
-  let(:match) { HttpStub::Server::Stub::Match::Match.new(request, response, stub) }
+  let(:match) { described_class.new(request, response, stub) }
 
   describe "#request" do
 

data/spec/lib/http_stub/server/stub/match/miss_spec.rb

@@ -1,8 +1,8 @@
 describe HttpStub::Server::Stub::Match::Miss do
 
-  let(:request)  { instance_double(HttpStub::Server::Request::Request) }
+  let(:request) { HttpStub::Server::RequestFixture.create }
 
-  let(:miss) { HttpStub::Server::Stub::Match::Miss.new(request) }
+  let(:miss) { described_class.new(request) }
 
   describe "#request" do
 

data/spec/lib/http_stub/server/stub/match/omitted_value_matcher_spec.rb

@@ -2,26 +2,30 @@ describe HttpStub::Server::Stub::Match::OmittedValueMatcher do
 
   describe "::match?" do
 
-    context "when the stubbed value is 'control:omitted'" do
+    let(:actual_value) { nil }
 
-      let(:stub_value) { "control:omitted" }
+    subject { described_class.match?(stub_value, actual_value) }
+
+    context "when the stub value is the symbol :omitted" do
+
+      let(:stub_value) { :omitted }
 
       context "and the actual value is nil" do
 
         let(:actual_value) { nil }
 
         it "returns true" do
-          expect(perform_match).to be_truthy
+          expect(subject).to be(true)
         end
 
       end
 
-      context "and the actual value is non-empty string" do
+      context "and the actual value is a non-empty string" do
 
         let(:actual_value) { "some non-empty string" }
 
         it "returns false" do
-          expect(perform_match).to be_falsey
+          expect(subject).to be(false)
         end
 
       end
@@ -31,26 +35,41 @@ describe HttpStub::Server::Stub::Match::OmittedValueMatcher do
         let(:actual_value) { "" }
 
         it "returns false" do
-          expect(perform_match).to be_falsey
+          expect(subject).to be(false)
         end
 
       end
 
     end
 
-    context "when the stub value is not 'control:omitted'" do
+    context "when the stub value is another symbol" do
+
+      let(:stub_value) { :some_other_symbol }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
+    end
+
+    context "when the stub value is a string" do
 
-      let(:stub_value) { "some other stub value" }
-      let(:actual_value) { nil }
+      let(:stub_value)   { "some string" }
 
       it "returns false" do
-        expect(perform_match).to be_falsey
+        expect(subject).to be(false)
       end
 
     end
 
-    def perform_match
-      HttpStub::Server::Stub::Match::OmittedValueMatcher.match?(stub_value, actual_value)
+    context "when the stub value is a regular expression" do
+
+      let(:stub_value) { /some regular expression/ }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
     end
 
   end

data/spec/lib/http_stub/server/stub/match/regexp_value_matcher_spec.rb

@@ -2,16 +2,18 @@ describe HttpStub::Server::Stub::Match::RegexpValueMatcher do
 
   describe "::match?" do
 
-    context "when the stub value is a string prefixed with 'regexp:'" do
+    subject { described_class.match?(stub_value, actual_value) }
 
-      let(:stub_value) { "regexp:^a[0-9]*\\$z$" }
+    context "when the stub value is a regular expression" do
+
+      let(:stub_value) { /^a[0-9]*\$z$/ }
 
       context "and the actual value matches the regular expression" do
 
         let(:actual_value) { "a789$z" }
 
         it "returns true" do
-          expect(perform_match).to be_truthy
+          expect(subject).to be(true)
         end
 
       end
@@ -21,26 +23,33 @@ describe HttpStub::Server::Stub::Match::RegexpValueMatcher do
         let(:actual_value) { "a789" }
 
         it "returns false" do
-          expect(perform_match).to be_falsey
+          expect(subject).to be(false)
         end
 
       end
 
     end
 
-    context "when the provided value is not a string prefixed with 'regexp'" do
+    context "when the stub value is a string" do
 
-      let(:stub_value) { "does not start with regexp:" }
-      let(:actual_value) { "some actual value" }
+      let(:stub_value)   { "some string" }
+      let(:actual_value) { stub_value }
 
       it "returns false" do
-        expect(perform_match).to be_falsey
+        expect(subject).to be(false)
       end
 
     end
-    
-    def perform_match
-      HttpStub::Server::Stub::Match::RegexpValueMatcher.match?(stub_value, actual_value)
+
+    context "when the stub value is a symbol" do
+
+      let(:stub_value)   { :some_symbol }
+      let(:actual_value) { stub_value }
+
+      it "returns false" do
+        expect(subject).to be(false)
+      end
+
     end
 
   end

data/spec/lib/http_stub/server/stub/match/rule/body_spec.rb

@@ -31,14 +31,14 @@ describe HttpStub::Server::Stub::Match::Rule::Body do
         let(:raw_schema)  { { "type" => "json", "definition" => json_schema } }
 
         it "creates a JSON request body with the schema" do
-          expect(HttpStub::Server::Stub::Match::Rule::JsonBody).to receive(:new).with(json_schema)
+          expect(HttpStub::Server::Stub::Match::Rule::JsonSchemaBody).to receive(:new).with(json_schema)
 
           subject
         end
 
         it "returns the created request body" do
-          json_body = instance_double(HttpStub::Server::Stub::Match::Rule::JsonBody)
-          allow(HttpStub::Server::Stub::Match::Rule::JsonBody).to receive(:new).and_return(json_body)
+          json_body = instance_double(HttpStub::Server::Stub::Match::Rule::JsonSchemaBody)
+          allow(HttpStub::Server::Stub::Match::Rule::JsonSchemaBody).to receive(:new).and_return(json_body)
 
           expect(subject).to eql(json_body)
         end

data/spec/lib/http_stub/server/stub/match/rule/{json_body_spec.rb → json_schema_body_spec.rb}

@@ -1,18 +1,18 @@
-describe HttpStub::Server::Stub::Match::Rule::JsonBody do
+describe HttpStub::Server::Stub::Match::Rule::JsonSchemaBody do
 
   let(:stub_schema_definition) { { "type" => "object", "properties" => { "some_property" => "some_type" } } }
 
-  let(:json_body) { described_class.new(stub_schema_definition) }
+  let(:json_schema_body) { described_class.new(stub_schema_definition) }
 
   describe "#matches?" do
 
     let(:request_body) { { "some_json_property" => "some_json_value" }.to_json }
-    let(:request)      { instance_double(HttpStub::Server::Request::Request, body: request_body) }
+    let(:request)      { HttpStub::Server::RequestFixture.create(body: request_body) }
     let(:logger)       { instance_double(Logger, info: nil) }
 
     let(:validation_errors) { [] }
 
-    subject { json_body.matches?(request, logger) }
+    subject { json_schema_body.matches?(request, logger) }
 
     before(:example) { allow(JSON::Validator).to receive(:fully_validate).and_return(validation_errors) }
 
@@ -90,7 +90,7 @@ describe HttpStub::Server::Stub::Match::Rule::JsonBody do
 
   describe "#to_s" do
 
-    subject { json_body.to_s }
+    subject { json_schema_body.to_s }
 
     it "returns the JSON representation of the schema definition" do
       expect(subject).to eql(stub_schema_definition.to_json)

data/spec/lib/http_stub/server/stub/match/rule/method_spec.rb

@@ -1,20 +1,20 @@
 describe HttpStub::Server::Stub::Match::Rule::Method do
 
-  let(:stub_method) { "put" }
+  let(:stub_method) { :put }
 
   let(:the_method) { described_class.new(stub_method) }
 
   describe "#matches?" do
 
     let(:request_method) { "get" }
-    let(:request)        { instance_double(HttpStub::Server::Request::Request, method: request_method) }
+    let(:request)        { HttpStub::Server::RequestFixture.create(method: request_method) }
     let(:logger)         { instance_double(Logger) }
 
     subject { the_method.matches?(request, logger) }
 
-    context "when the request method is identical to the stub method" do
+    context "when the stub method is identical to the request method" do
 
-      let(:request_method) { stub_method }
+      let(:stub_method) { request_method }
 
       it "returns true" do
         expect(subject).to be(true)
@@ -22,7 +22,7 @@ describe HttpStub::Server::Stub::Match::Rule::Method do
 
     end
 
-    context "when the stub method and request method are the the same value but have different casing" do
+    context "when the stub and request methods are the same value but have different casing" do
 
       let(:stub_method) { "GET" }
 
@@ -32,6 +32,26 @@ describe HttpStub::Server::Stub::Match::Rule::Method do
 
     end
 
+    context "when the stub and request methods are the same value but the stub method is symbolised" do
+
+      let(:stub_method) { :get }
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+    end
+
+    context "when the stub and request methods are the same but the stub method is symbolised with different casing" do
+
+      let(:stub_method) { :GET }
+
+      it "returns true" do
+        expect(subject).to be(true)
+      end
+
+    end
+
     context "when the stub method is omitted" do
 
       context "with a nil value" do
@@ -75,10 +95,24 @@ describe HttpStub::Server::Stub::Match::Rule::Method do
 
     context "when the stub method is not nil" do
 
-      let(:stub_method) { "present" }
+      context "and is a string" do
+
+        let(:stub_method) { "present" }
+
+        it "returns the capitalised stub method" do
+          expect(subject).to eql("PRESENT")
+        end
+
+      end
+
+      context "and is a symbol" do
+
+        let(:stub_method) { :present }
+
+        it "returns the method as a capitalised string" do
+          expect(subject).to eql("PRESENT")
+        end
 
-      it "returns the stub method" do
-        expect(subject).to eql(stub_method)
       end
 
     end

data/spec/lib/http_stub/server/stub/match/rule/schema_body_spec.rb

@@ -0,0 +1,64 @@
+describe HttpStub::Server::Stub::Match::Rule::SchemaBody do
+
+  class HttpStub::Server::Stub::Match::Rule::TestSchemaBody
+
+    attr_reader :definition
+
+    def initialize(definition)
+      @definition = definition
+    end
+
+  end
+
+  describe "::create" do
+
+    subject { described_class.create(args) }
+
+    context "when a supported type is specified" do
+
+      let(:definition) { "some definition" }
+      let(:args)       { { type: :test, definition: "some definition" } }
+
+      it "creates a schema body of the specified type" do
+        expect(subject).to be_an_instance_of(HttpStub::Server::Stub::Match::Rule::TestSchemaBody)
+      end
+
+      it "creates a body with the specified definition" do
+        expect(subject.definition).to eql(definition)
+      end
+
+    end
+
+    context "when an unsupported type is specified" do
+
+      let(:args) { { type: :not_supported, definition: "some definition" } }
+
+      it "raises an error indicating the schema type is not supported" do
+        expect { subject }.to raise_error(/not_supported schema is not supported/)
+      end
+
+    end
+
+    context "when the schema type is not specified" do
+
+      let(:args) { { definition: "some definition" } }
+
+      it "raises an error indicating the type is mandatory" do
+        expect { subject }.to raise_error(/type expected/)
+      end
+
+    end
+
+    context "when the schema definition is not specified" do
+
+      let(:args) { { type: :test } }
+
+      it "raises an error indicating the type is mandatory" do
+        expect { subject }.to raise_error(/definition expected/)
+      end
+
+    end
+
+  end
+
+end