pacto 0.2.5 → 0.3.0.pre

data/spec/unit/pacto/request_spec.rb

@@ -1,12 +1,13 @@
 module Pacto
   describe Request do
-    let(:host) { 'http://localhost' }
-    let(:method) { 'GET' }
-    let(:path) { '/hello_world' }
-    let(:headers) { {'accept' => 'application/json'} }
-    let(:params) { {'foo' => 'bar'} }
-
-    let(:request) do
+    let(:host)           { 'http://localhost' }
+    let(:method)         { 'GET' }
+    let(:path)           { '/hello_world' }
+    let(:headers)        { {'accept' => 'application/json'} }
+    let(:params)         { {'foo' => 'bar'} }
+    let(:params_as_json) { "{\"foo\":\"bar\"}" }
+    let(:absolute_uri)   { "#{host}#{path}" }
+    subject(:request) do
       described_class.new(host, {
         'method'  => method,
         'path'    => path,
@@ -14,58 +15,106 @@ module Pacto
         'params'  => params
       })
     end
-    subject { request }
 
-    its(:method) { should == :get }
-    its(:path) { should == path }
-    its(:headers) { should == headers }
-    its(:params) { should == params }
+    it 'has a host' do
+      expect(request.host).to eq host
+    end
+
+    describe '#method' do
+      it 'delegates to definition' do
+        expect(request.method).to eq :get
+      end
+
+      it 'downcases the method' do
+        expect(request.method).to eq request.method.downcase
+      end
+
+      it 'returns a symbol' do
+        expect(request.method).to be_kind_of Symbol
+      end
+    end
+
+    describe '#path' do
+      it 'delegates to definition' do
+        expect(request.path).to eq path
+      end
+    end
+
+    describe '#headers' do
+      it 'delegates to definition' do
+        expect(request.headers).to eq headers
+      end
+    end
+
+    describe '#params' do
+      it 'delegates to definition' do
+        expect(request.params).to eq params
+      end
+    end
 
     describe '#execute' do
-      let(:connection) { double('connection') }
-      let(:response) { double('response') }
-      let(:adapted_response) { double('adapted response') }
+      let(:connection)       { double 'connection' }
+      let(:response)         { double 'response' }
+      let(:adapted_response) { double 'adapted response' }
+
+      before do
+        HTTParty.stub(:get => response)
+        HTTParty.stub(:post => response)
+        ResponseAdapter.stub(:new => adapted_response)
+      end
+
+      context 'for any request' do
+        it 'processes the response with an ResponseAdapter' do
+          ResponseAdapter.should_receive(:new).
+            with(response).
+            and_return(adapted_response)
+          request.execute
+        end
+
+        it 'returns the adapted response' do
+          expect(request.execute).to be adapted_response
+        end
+      end
 
       context 'for a GET request' do
-        it 'should make a GET request and return the response' do
+        it 'makes the request thru the http client' do
           HTTParty.should_receive(:get).
-            with(host + path, {:query => params, :headers => headers}).
+            with(absolute_uri, {:query => params, :headers => headers}).
             and_return(response)
-          ResponseAdapter.should_receive(:new).with(response).and_return(adapted_response)
-          request.execute.should == adapted_response
+          request.execute
         end
       end
 
       context 'for a POST request' do
-        let(:method) { 'POST' }
+        let(:method)  { 'POST' }
 
-        it 'should make a POST request and return the response' do
+        it 'makes the request thru the http client' do
           HTTParty.should_receive(:post).
-            with(host + path, {:body => params.to_json, :headers => headers}).
+            with(absolute_uri, {:body => params_as_json, :headers => headers}).
             and_return(response)
-          ResponseAdapter.should_receive(:new).with(response).and_return(adapted_response)
-          request.execute.should == adapted_response
+          request.execute
         end
       end
     end
 
-    describe "#absolute_uri" do
-      it "should be equal to the host followed by the path" do
-        request.absolute_uri.should == "http://localhost/hello_world"
+    describe '#absolute_uri' do
+      it 'returns the host followed by the path' do
+        expect(request.absolute_uri).to eq absolute_uri
       end
     end
 
-    describe "#full_uri" do
-      context "when the query (params) exists" do
-        it "should be equal to the host followed by the path and the query" do
-          request.full_uri.should == "http://localhost/hello_world?foo=bar"
+    describe '#full_uri' do
+      context 'when the request has a query' do
+        it 'returns the host followed by the path and the query' do
+          expect(request.full_uri).to eq 'http://localhost/hello_world?foo=bar'
         end
       end
 
-      context "when the query (params) does not exists" do
+      context 'when the query does not have a query' do
         let(:params) { {} }
-        it "should be equal to the host followed by the path" do
-          request.full_uri.should == "http://localhost/hello_world"
+
+        it 'returns the host followed by the path' do
+          expect(request.absolute_uri).to eq 'http://localhost/hello_world'
         end
       end
     end

data/spec/unit/pacto/response_adapter_spec.rb

@@ -1,27 +1,25 @@
 module Pacto
   describe ResponseAdapter do
     let(:response) do
-      double({
+      double(
         :code => 200,
         :headers => {'foo' => ['bar', 'baz'], 'hello' => ['world']},
         :body => double('body')
-      })
+      )
     end
 
-    before do
-      @response_adapter = described_class.new(response)
-    end
+    subject(:response_adapter) { described_class.new response }
 
-    it 'should have a status' do
-      @response_adapter.status.should == response.code
+    it 'has a status' do
+      expect(response_adapter.status).to eq response.code
     end
 
-    it 'should have a body' do
-      @response_adapter.body.should == response.body
+    it 'has a body' do
+      expect(response_adapter.body).to eq response.body
     end
 
-    it 'should normalize headers values according to RFC2616' do
-      @response_adapter.headers.should == {'foo' => 'bar,baz', 'hello' => 'world'}
+    it 'normalizes headers values according to RFC2616' do
+      expect(response_adapter.headers).to eq({'foo' => 'bar,baz', 'hello' => 'world'})
     end
   end
 end

data/spec/unit/pacto/response_spec.rb

@@ -1,7 +1,7 @@
 module Pacto
-	describe Response do
+  describe Response do
     let(:body_definition) do
-      {:type => "object", :required => true, :properties => double("body definition properties")}
+      {:type => 'object', :required => true, :properties => double('body definition properties')}
     end
     let(:definition) do
       {
@@ -11,20 +11,20 @@ module Pacto
       }
     end
 
-		describe '#instantiate' do
-			let(:generated_body) { double('generated body') }
+    describe '#instantiate' do
+      let(:generated_body) { double('generated body') }
 
-			it 'should instantiate a response with a body that matches the given definition' do
-				JSON::Generator.should_receive(:generate).
-					with(definition['body']).
-					and_return(generated_body)
+      it 'instantiates a response with a body that matches the given definition' do
+        JSON::Generator.should_receive(:generate).
+          with(definition['body']).
+          and_return(generated_body)
 
-				response = described_class.new(definition).instantiate
-				response.status.should == definition['status']
-				response.headers.should == definition['headers']
-				response.body.should == generated_body
-			end
-		end
+        response = described_class.new(definition).instantiate
+        expect(response.status).to eq definition['status']
+        expect(response.headers).to eq definition['headers']
+        expect(response.body).to eq generated_body
+      end
+    end
 
     describe '#validate' do
       let(:status) { 200 }
@@ -39,142 +39,142 @@ module Pacto
       end
 
       context 'when status, headers and body match' do
-        it 'should not return any errors' do
+        it 'does not return any errors' do
           JSON::Validator.should_receive(:fully_validate).
-            with(definition['body'], fake_response.body).
+            with(definition['body'], fake_response.body, :version => :draft3).
             and_return([])
 
           response = described_class.new(definition)
-          response.validate(fake_response).should == []
+          expect(response.validate(fake_response)).to be_empty
         end
       end
-      
+
       context 'when body is a pure string and matches the description' do
         let(:string_required) { true }
         let(:body_definition) do
           { 'type' => 'string', 'required' => string_required }
         end
-        let(:response_body) { "a simple string" }
-        
-        it 'should not validate using JSON Schema' do
+        let(:response_body) { 'a simple string' }
+
+        it 'does not validate using JSON Schema' do
           response = described_class.new(definition)
-          
+
           JSON::Validator.should_not_receive(:fully_validate)
           response.validate(fake_response)
         end
-        
+
         context 'if required' do
-          it 'should not return an error when body is a string' do
+          it 'does not return an error when body is a string' do
             response = described_class.new(definition)
-          
-            response.validate(fake_response).should == []
+
+            expect(response.validate(fake_response)).to be_empty
           end
-          
-          it 'should return an error when body is nil' do
+
+          it 'returns an error when body is nil' do
             response = described_class.new(definition)
-            
+
             fake_response.stub(:body).and_return(nil)
-            response.validate(fake_response).size.should == 1
+            expect(response.validate(fake_response).size).to eq 1
           end
         end
-        
+
         context 'if not required' do
           let(:string_required) { false }
-          
-          it 'should not return an error when body is a string' do
+
+          it 'does not return an error when body is a string' do
             response = described_class.new(definition)
-          
-            response.validate(fake_response).should == []
+
+            expect(response.validate(fake_response)).to be_empty
           end
-          
-          it 'should not return an error when body is nil' do
+
+          it 'does not return an error when body is nil' do
             response = described_class.new(definition)
-            
+
             fake_response.stub(:body).and_return(nil)
-            response.validate(fake_response).should == []
+            expect(response.validate(fake_response)).to be_empty
           end
         end
-        
+
         context 'if contains pattern' do
           let(:body_definition) do
             { 'type' => 'string', 'required' => string_required, 'pattern' => 'a.c' }
           end
-          
+
           context 'body matches pattern' do
             let(:response_body) { 'cabcd' }
-            
-            it "should not return an error" do
+
+            it 'does not return an error' do
               response = described_class.new(definition)
-              
-              response.validate(fake_response).should == []
+
+              expect(response.validate(fake_response)).to be_empty
             end
           end
-          
+
           context 'body does not match pattern' do
             let(:response_body) { 'cabscd' }
-            
-            it "should return an error" do
+
+            it 'returns an error' do
               response = described_class.new(definition)
-              
-              response.validate(fake_response).size.should == 1
+
+              expect(response.validate(fake_response).size).to eq 1
             end
           end
-          
+
         end
       end
-      
+
       context 'when status does not match' do
         let(:status) { 500 }
 
-        it 'should return a status error' do
+        it 'returns a status error' do
           JSON::Validator.should_not_receive(:fully_validate)
-          
+
           response = described_class.new(definition)
-          response.validate(fake_response).should == ["Invalid status: expected #{definition['status']} but got #{status}"]
+          expect(response.validate(fake_response)).to eq ["Invalid status: expected #{definition['status']} but got #{status}"]
         end
       end
 
       context 'when headers do not match' do
         let(:headers) { {'Content-Type' => 'text/html'} }
 
-        it 'should return a header error' do
+        it 'returns a header error' do
           JSON::Validator.should_not_receive(:fully_validate)
 
           response = described_class.new(definition)
-          response.validate(fake_response).should == ["Invalid headers: expected #{definition['headers'].inspect} to be a subset of #{headers.inspect}"]
+          expect(response.validate(fake_response)).to eq ["Invalid headers: expected #{definition['headers'].inspect} to be a subset of #{headers.inspect}"]
         end
       end
 
       context 'when headers are a subset of expected headers' do
         let(:headers) { {'Content-Type' => 'application/json'} }
 
-        it 'should not return any errors' do
+        it 'does not return any errors' do
           JSON::Validator.stub(:fully_validate).and_return([])
 
           response = described_class.new(definition)
-          response.validate(fake_response).should == []
+          expect(response.validate(fake_response)).to be_empty
         end
       end
 
       context 'when headers values match but keys have different case' do
         let(:headers) { {'content-type' => 'application/json'} }
 
-        it 'should not return any errors' do
+        it 'does not return any errors' do
           JSON::Validator.stub(:fully_validate).and_return([])
 
           response = described_class.new(definition)
-          response.validate(fake_response).should == []
+          expect(response.validate(fake_response)).to be_empty
         end
       end
 
       context 'when body does not match' do
         let(:errors) { [double('error1'), double('error2')] }
 
-        it 'should return a list of errors' do
+        it 'returns a list of errors' do
           JSON::Validator.stub(:fully_validate).and_return(errors)
 
           response = described_class.new(definition)
-          response.validate(fake_response).should == errors
+          expect(response.validate(fake_response)).to eq errors
         end
       end
 
@@ -186,16 +186,16 @@ module Pacto
           }
         end
 
-        it 'should not validate body' do
+        it 'does not validate body' do
           JSON::Validator.should_not_receive(:fully_validate)
-          response = described_class.new(definition)
+          described_class.new(definition)
         end
 
-        it 'should give no errors' do
+        it 'gives no errors' do
           response = described_class.new(definition)
-          response.validate(fake_response).should == []
+          expect(response.validate(fake_response)).to be_empty
         end
       end
     end
-	end
+  end
 end

data/spec/unit/pacto/server/playback_servlet_spec.rb

@@ -0,0 +1,24 @@
+module Pacto::Server
+  describe PlaybackServlet do
+    let(:request) { double }
+    let(:response) { double('response', :status= => '', :[]= => '', :body= => '') }
+
+    it 'alters response data with recorded status' do
+      servlet = PlaybackServlet.new status: 200
+      servlet.do_GET(request, response)
+      expect(response).to have_received(:status=).with(200)
+    end
+
+    it 'alters reponse data with recorded headers' do
+      servlet = PlaybackServlet.new headers: {'Content-Type' => 'application/json'}
+      servlet.do_GET(request, response)
+      expect(response).to have_received(:[]=).with('Content-Type', 'application/json')
+    end
+
+    it 'alters reponse data with recorded ' do
+      servlet = PlaybackServlet.new body: 'recorded'
+      servlet.do_GET(request, response)
+      expect(response).to have_received(:body=).with('recorded')
+    end
+  end
+end