pacto 0.0.1

data/lib/pacto/request.rb

@@ -0,0 +1,58 @@
+module Pacto
+  class Request
+    def initialize(host, definition)
+      @host = host
+      @definition = definition
+    end
+
+    def host
+      @host
+    end
+
+    def method
+      @definition['method'].to_s.downcase.to_sym
+    end
+
+    def path
+      @definition['path']
+    end
+
+    def headers
+      @definition['headers']
+    end
+
+    def params
+      @definition['params']
+    end
+
+    def absolute_uri
+      @host + path
+    end
+
+    def full_uri
+      return absolute_uri if params.empty?
+
+      uri = Addressable::URI.new
+      uri.query_values = params
+
+      absolute_uri + '?' + uri.query
+    end
+
+    def execute
+      response = HTTParty.send(method, @host + path, {
+        httparty_params_key => normalized_params,
+        :headers => headers
+      })
+      ResponseAdapter.new(response)
+    end
+
+    private
+    def httparty_params_key
+      method == :get ? :query : :body
+    end
+
+    def normalized_params
+      method == :get ? params : params.to_json
+    end
+  end
+end

data/lib/pacto/response.rb

@@ -0,0 +1,27 @@
+module Pacto
+  class Response
+    def initialize(definition)
+      @definition = definition
+    end
+
+    def instantiate
+      OpenStruct.new({
+        'status' => @definition['status'],
+        'headers' => @definition['headers'],
+        'body' => JSON::Generator.generate(@definition['body'])
+      })
+    end
+
+    def validate(response)
+      @errors = []
+      if @definition['status'] != response.status
+        @errors << "Invalid status: expected #{@definition['status']} but got #{response.status}"
+      end
+      unless @definition['headers'].normalize_keys.subset_of?(response.headers.normalize_keys)
+        @errors << "Invalid headers: expected #{@definition['headers'].inspect} to be a subset of #{response.headers.inspect}"
+      end
+      @errors << JSON::Validator.fully_validate(@definition['body'], response.body)
+      @errors.flatten
+    end
+  end
+end

data/lib/pacto/response_adapter.rb

@@ -0,0 +1,24 @@
+module Pacto
+  class ResponseAdapter
+    def initialize(response)
+      @response = response
+    end
+
+    def status
+      @response.code
+    end
+
+    def body
+      @response.body
+    end
+
+    def headers
+      # Normalize headers values according to RFC2616
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+      normalized_headers = @response.headers.map do |(key, value)|
+        [key, value.join(',')]
+      end
+      Hash[normalized_headers]
+    end
+  end
+end

data/lib/pacto/version.rb

@@ -0,0 +1,3 @@
+module Pacto
+  VERSION = "0.0.1"
+end

data/pacto.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pacto/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pacto"
+  gem.version       = Pacto::VERSION
+  gem.authors       = ["ThoughtWorks & Abril"]
+  gem.email         = ["abril_vejasp_dev@thoughtworks.com"]
+  gem.description   = %q{Pacto is a Ruby implementation of the [Consumer-Driven Contracts](http://martinfowler.com/articles/consumerDrivenContracts.html) pattern for evolving services}
+  gem.summary       = %q{Consumer-Driven Contracts implementation}
+  gem.homepage      = 'https://github.com/thoughtworks/pacto'
+  gem.license       = 'MIT'
+
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "webmock"
+  gem.add_dependency "json"
+  gem.add_dependency "json-schema", "1.0.4"
+  gem.add_dependency "json-generator"
+  gem.add_dependency "hash-deep-merge"
+  gem.add_dependency "httparty"
+  gem.add_dependency "addressable"
+  gem.add_dependency "coveralls"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "guard-rspec"
+  gem.add_development_dependency "rb-fsevent" if RUBY_PLATFORM =~ /darwin/i
+  gem.add_development_dependency "terminal-notifier-guard" if RUBY_PLATFORM =~ /darwin/i
+end

data/spec/data/contract.json

@@ -0,0 +1,25 @@
+{
+  "request": {
+    "method": "GET",
+    "path": "/hello_world",
+    "headers": {
+      "Accept": "application/json"
+    }
+  },
+
+  "response": {
+    "status": 200,
+    "headers": {
+      "Content-Type": "application/json"
+    },
+    "body": {
+      "description": "A simple response",
+      "type": "object",
+      "properties": {
+        "message": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

data/spec/pacto/contract_spec.rb

@@ -0,0 +1,50 @@
+module Pacto
+  describe Contract do
+    let(:request) { double('request') }
+    let(:response) { double('response') }
+
+    let(:contract) { described_class.new(request, response) }
+
+    describe '#instantiate' do
+      let(:instantiated_response) { double('instantiated response') }
+      let(:instantiated_contract) { double('instantiated contract') }
+
+      context 'by default' do
+        it 'should instantiate a contract with default attributes' do
+          response.should_receive(:instantiate).and_return(instantiated_response)
+          InstantiatedContract.should_receive(:new).
+            with(request, instantiated_response).
+            and_return(instantiated_contract)
+          instantiated_contract.should_not_receive(:replace!)
+
+          contract.instantiate.should == instantiated_contract
+        end
+      end
+
+      context 'with extra attributes' do
+        let(:attributes) { {:foo => 'bar'} }
+
+        it 'should instantiate a contract and overwrite default attributes' do
+          response.should_receive(:instantiate).and_return(instantiated_response)
+          InstantiatedContract.should_receive(:new).
+            with(request, instantiated_response).
+            and_return(instantiated_contract)
+          instantiated_contract.should_receive(:replace!).with(attributes)
+
+          contract.instantiate(attributes).should == instantiated_contract
+        end
+      end
+    end
+
+    describe '#validate' do
+      let(:fake_response) { double('fake response') }
+      let(:validation_result) { double('validation result') }
+
+      it 'should execute the request and match it against the expected response' do
+        request.should_receive(:execute).and_return(fake_response)
+        response.should_receive(:validate).with(fake_response).and_return(validation_result)
+        contract.validate.should == validation_result
+      end
+    end
+  end
+end

data/spec/pacto/extensions_spec.rb

@@ -0,0 +1,34 @@
+module Pacto
+  module Extensions
+    describe HashSubsetOf do
+      describe '#subset_of?' do
+        context 'when the other hash is the same' do
+          it 'should return true' do
+            {:a => 'a'}.should be_subset_of({:a => 'a'})
+          end
+        end
+
+        context 'when the other hash is a subset' do
+          it 'should return true' do
+            {:a => 'a'}.should be_subset_of({:a => 'a', :b => 'b'})
+          end
+        end
+
+        context 'when the other hash is not a subset' do
+          it 'should return false' do
+            {:a => 'a'}.subset_of?({:a => 'b'}).should be_false
+          end
+        end
+      end
+
+      describe '#normalize_keys' do
+        it 'should turn keys into downcased strings' do
+          {:A => 'a'}.normalize_keys.should == {'a' => 'a'}
+          {:a => 'a'}.normalize_keys.should == {'a' => 'a'}
+          {'A' => 'a'}.normalize_keys.should == {'a' => 'a'}
+          {'a' => 'a'}.normalize_keys.should == {'a' => 'a'}
+        end
+      end
+    end
+  end
+end

data/spec/pacto/file_pre_processor_spec.rb

@@ -0,0 +1,13 @@
+module Pacto
+  describe FilePreProcessor do
+    describe "#process" do
+      it "should return the result of ERB" do
+        subject.process("2 + 2 = <%= 2 + 2 %>").should == "2 + 2 = 4"
+      end
+      
+      it "should not mess with pure JSONs" do
+        subject.process('{"property": ["one", "two, null"]}')
+      end
+    end
+  end
+end

data/spec/pacto/instantiated_contract_spec.rb

@@ -0,0 +1,224 @@
+module Pacto
+	describe InstantiatedContract do
+		describe '#replace!' do
+      let(:body) { double('body') }
+      let(:response) { double(:body => body) }
+      let(:values) { double('values') }
+
+      context 'when response body is a hash' do
+        let(:normalized_values) { double('normalized values') }
+        let(:normalized_body) { double('normalized body') }
+        let(:merged_body) { double('merged body') }
+
+        it 'should normalize keys and deep merge response body with given values' do
+          values.should_receive(:normalize_keys).and_return(normalized_values)
+          response.body.should_receive(:normalize_keys).and_return(normalized_body)
+          normalized_body.should_receive(:deep_merge).with(normalized_values).and_return(merged_body)
+
+          instantiated_contract = described_class.new(nil, response)
+          instantiated_contract.replace!(values)
+
+          instantiated_contract.response_body.should == merged_body
+        end
+      end
+
+      context 'when response body is a string' do
+        let(:body) { 'foo' }
+
+        it 'should replace response body with given values' do
+          instantiated_contract = described_class.new(nil, response)
+          instantiated_contract.replace!(values)
+          instantiated_contract.response_body.should == values
+        end
+      end
+
+      context 'when response body is nil' do
+        let(:body) { nil }
+
+        it 'should replace response body with given values' do
+          instantiated_contract = described_class.new(nil, response)
+          instantiated_contract.replace!(values)
+          instantiated_contract.response_body.should == values
+        end
+      end
+    end
+
+    describe '#response_body' do
+      let(:response) { double(:body => double('body')) }
+
+      it "should return response body" do
+        described_class.new(nil, response).response_body.should == response.body
+      end
+    end
+
+    describe '#request_path' do
+      let(:request) { double('request', :absolute_uri => "http://dummy_link/hello_world") }
+      let(:response) { double('response', :body => double('body')) }
+
+      it "should return the request absolute uri" do
+        described_class.new(request, response).request_path.should == "http://dummy_link/hello_world"
+      end
+    end
+
+    describe '#request_uri' do
+      let(:request) { double('request', :full_uri => "http://dummy_link/hello_world?param=value#fragment") }
+      let(:response) { double('response', :body => double('body')) }
+
+      it "should return request full uri" do
+        described_class.new(request, response).request_uri.should == "http://dummy_link/hello_world?param=value#fragment"
+      end
+    end
+
+    describe '#stub!' do
+      let(:request) do
+        double({
+          :host => 'http://localhost',
+          :method => method,
+          :path => '/hello_world',
+          :headers => {'Accept' => 'application/json'},
+          :params => {'foo' => 'bar'}
+        })
+      end
+
+      let(:method) { :get }
+
+      let(:response) do
+        double({
+          :status => 200,
+          :headers => {},
+          :body => body
+        })
+      end
+
+      let(:body) do
+        {'message' => 'foo'}
+      end
+
+      let(:stubbed_request) { double('stubbed request') }
+
+      before do
+        WebMock.should_receive(:stub_request).
+          with(request.method, "#{request.host}#{request.path}").
+          and_return(stubbed_request)
+
+        stubbed_request.stub(:to_return).with({
+          :status => response.status,
+          :headers => response.headers,
+          :body => response.body.to_json
+        })
+      end
+
+      context 'when the response body is an object' do
+        let(:body) do
+          {'message' => 'foo'}
+        end
+
+        it 'should stub the response body with a json representation' do
+          stubbed_request.should_receive(:to_return).with({
+            :status => response.status,
+            :headers => response.headers,
+            :body => response.body.to_json
+          })
+
+          stubbed_request.stub(:with).and_return(stubbed_request)
+
+          described_class.new(request, response).stub!
+        end
+      end
+
+      context 'when the response body is an array' do
+        let(:body) do
+          [1, 2, 3]
+        end
+
+        it 'should stub the response body with a json representation' do
+          stubbed_request.should_receive(:to_return).with({
+            :status => response.status,
+            :headers => response.headers,
+            :body => response.body.to_json
+          })
+
+          stubbed_request.stub(:with).and_return(stubbed_request)
+
+          described_class.new(request, response).stub!
+        end
+      end
+
+      context 'when the response body is not an object or an array' do
+        let(:body) { nil }
+
+        it 'should stub the response body with the original body' do
+          stubbed_request.should_receive(:to_return).with({
+            :status => response.status,
+            :headers => response.headers,
+            :body => response.body
+          })
+
+          stubbed_request.stub(:with).and_return(stubbed_request)
+
+          described_class.new(request, response).stub!
+        end
+      end
+
+      context 'a GET request' do
+        let(:method) { :get }
+
+        it 'should use WebMock to stub the request' do
+          stubbed_request.should_receive(:with).
+            with({:headers => request.headers, :query => request.params}).
+            and_return(stubbed_request)
+          described_class.new(request, response).stub!
+        end
+      end
+
+      context 'a POST request' do
+        let(:method) { :post }
+
+        it 'should use WebMock to stub the request' do
+          stubbed_request.should_receive(:with).
+            with({:headers => request.headers, :body => request.params}).
+            and_return(stubbed_request)
+          described_class.new(request, response).stub!
+        end
+      end
+
+      context 'a request with no headers' do
+        let(:request) do
+          double({
+            :host => 'http://localhost',
+            :method => :get,
+            :path => '/hello_world',
+            :headers => {},
+            :params => {'foo' => 'bar'}
+          })
+        end
+
+        it 'should use WebMock to stub the request' do
+          stubbed_request.should_receive(:with).
+            with({:query => request.params}).
+            and_return(stubbed_request)
+          described_class.new(request, response).stub!
+        end
+      end
+
+      context 'a request with no params' do
+        let(:request) do
+          double({
+            :host => 'http://localhost',
+            :method => :get,
+            :path => '/hello_world',
+            :headers => {},
+            :params => {}
+          })
+        end
+
+        it 'should use WebMock to stub the request' do
+          stubbed_request.should_receive(:with).
+            with({}).
+            and_return(stubbed_request)
+          described_class.new(request, response).stub!
+        end
+      end
+    end
+	end
+end