contracts_api_test 0.0.1

data/lib/contracts/request.rb

@@ -0,0 +1,62 @@
+module Contracts
+  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 path=(value)
+      @definition['path'] = value
+    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/contracts/response.rb

@@ -0,0 +1,27 @@
+module Contracts
+  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/contracts/response_adapter.rb

@@ -0,0 +1,24 @@
+module Contracts
+  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/contracts/version.rb

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

data/lib/json-generator.rb

@@ -0,0 +1 @@
+require 'json/generator'

data/lib/json/generator.rb

@@ -0,0 +1,18 @@
+require "json/generator/basic_attribute"
+require "json/generator/empty_attribute"
+require "json/generator/string_attribute"
+require "json/generator/integer_attribute"
+require "json/generator/array_attribute"
+require "json/generator/object_attribute"
+require "json/generator/boolean_attribute"
+require "json/generator/attribute_factory"
+require "json/generator/dereferencer"
+
+module JSON
+  module Generator
+    def self.generate(schema)
+      dereferenced_schema = Dereferencer.dereference(schema)
+      AttributeFactory.create(dereferenced_schema).generate
+    end
+  end
+end

data/lib/json/generator/array_attribute.rb

@@ -0,0 +1,11 @@
+module JSON
+  module Generator
+    class ArrayAttribute < BasicAttribute
+      def generate
+        (@attributes['minItems'] || 0).times.map do |index|
+          AttributeFactory.create(@attributes['items']).generate
+        end
+      end
+    end
+  end
+end

data/lib/json/generator/attribute_factory.rb

@@ -0,0 +1,18 @@
+module JSON
+  module Generator
+    class AttributeFactory
+      CLASSES = {
+        'string' => StringAttribute,
+        'object' => ObjectAttribute,
+        'integer' => IntegerAttribute,
+        'array' => ArrayAttribute,
+        'boolean' => BooleanAttribute,
+        nil => EmptyAttribute
+      }
+
+      def self.create(properties)
+        CLASSES[Array(properties['type']).first].new(properties)
+      end
+    end
+  end
+end

data/lib/json/generator/basic_attribute.rb

@@ -0,0 +1,17 @@
+module JSON
+  module Generator
+    class BasicAttribute
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def generate
+        @attributes['default'] || self.class::DEFAULT_VALUE
+      end
+
+      def required?
+        @attributes['required']
+      end
+    end
+  end
+end

data/lib/json/generator/boolean_attribute.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Generator
+    class BooleanAttribute < BasicAttribute
+      DEFAULT_VALUE = false
+    end
+  end
+end

data/lib/json/generator/dereferencer.rb

@@ -0,0 +1,22 @@
+module JSON
+  module Generator
+    class Dereferencer
+      def self.dereference(schema)
+        return schema unless schema.has_key?('properties')
+
+        definitions = schema.delete('definitions')
+        schema['properties'].each do |name, property|
+          next unless property.has_key?('$ref')
+
+          ref_name = property['$ref'].split('/').last
+          raise NameError, "definition for #{ref_name} not found" unless definitions.has_key?(ref_name)
+
+          property.merge!(definitions[ref_name])
+          property.delete('$ref')
+        end
+
+        schema
+      end
+    end
+  end
+end

data/lib/json/generator/empty_attribute.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Generator
+    class EmptyAttribute < BasicAttribute
+      DEFAULT_VALUE = nil
+    end
+  end
+end

data/lib/json/generator/integer_attribute.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Generator
+    class IntegerAttribute < BasicAttribute
+      DEFAULT_VALUE = 0
+    end
+  end
+end

data/lib/json/generator/object_attribute.rb

@@ -0,0 +1,18 @@
+module JSON
+  module Generator
+    class ObjectAttribute < BasicAttribute
+      def generate
+        return nil unless required?
+        return {} unless @attributes.has_key?('properties')
+
+        @attributes['properties'].inject({}) do |json, (property_name, property_attributes)|
+          attribute = AttributeFactory.create(property_attributes)
+          if attribute.required?
+            json[property_name] = attribute.generate
+          end
+          json
+        end
+      end
+    end
+  end
+end

data/lib/json/generator/string_attribute.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Generator
+    class StringAttribute < BasicAttribute
+      DEFAULT_VALUE = "bar"
+    end
+  end
+end

data/spec/contracts/contract_spec.rb

@@ -0,0 +1,50 @@
+module Contracts
+  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/contracts/contracts_spec.rb

@@ -0,0 +1,77 @@
+describe Contracts do
+  let(:host) { 'http://localhost' }
+  let(:contract_name) { 'contract' }
+  let(:contract_path) { File.join('spec', 'data', "#{contract_name}.json") }
+  let(:contract) { double('contract') }
+
+  after do
+    described_class.unregister_all!
+  end
+
+  describe '.register' do
+    context 'by default' do
+      it 'should register a contract under a given name' do
+        described_class.register(contract_name, contract)
+        described_class.registered[contract_name].should == contract
+      end
+    end
+
+    context 'when a contract has already been registered with the same name' do
+      it 'should raise an argument error' do
+        described_class.register(contract_name, contract)
+        expect { described_class.register(contract_name, contract) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '.build_from_file' do
+    it 'should build a contract given a file path and a host' do
+      described_class.build_from_file(contract_path, host).should be_a_kind_of(Contracts::Contract)
+    end
+  end
+
+  describe '.use' do
+    before do
+      described_class.register(contract_name, contract)
+    end
+
+    context 'by default' do
+      let(:instantiated_contract) { double('instantiated contract', :response_body => response_body)}
+      let(:response_body) { double('response_body') }
+
+      before do
+        described_class.registered[contract_name].stub(:instantiate => instantiated_contract)
+        instantiated_contract.stub(:stub!)
+      end
+
+      it 'should instantiate a contract with default values' do
+        described_class.registered[contract_name].should_receive(:instantiate).with(nil).and_return(instantiated_contract)
+        described_class.use(contract_name)
+      end
+
+      it 'should return the instantiated contract' do
+        described_class.use(contract_name).should == instantiated_contract
+      end
+
+      it 'should stub further requests with the instantiated contract' do
+        instantiated_contract.should_receive(:stub!)
+        described_class.use(contract_name)
+      end
+
+    end
+
+    context 'when contract has not been registered' do
+      it 'should raise an argument error' do
+        expect { described_class.use('unregistered') }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '.unregister_all!' do
+    it 'should unregister all previously registered contracts' do
+      described_class.register(contract_name, contract)
+      described_class.unregister_all!
+      described_class.registered.should be_empty
+    end
+  end
+end

data/spec/contracts/extensions_spec.rb

@@ -0,0 +1,34 @@
+module Contracts
+  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/contracts/instantiated_contract_spec.rb

@@ -0,0 +1,224 @@
+module Contracts
+	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