contracts_api_test 0.0.1

data/spec/contracts/request_spec.rb

@@ -0,0 +1,73 @@
+module Contracts
+  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
+      described_class.new(host, {
+        'method'  => method,
+        'path'    => path,
+        'headers' => headers,
+        'params'  => params
+      })
+    end
+    subject { request }
+
+    its(:method) { should == :get }
+    its(:path) { should == path }
+    its(:headers) { should == headers }
+    its(:params) { should == params }
+
+    describe '#execute' do
+      let(:connection) { double('connection') }
+      let(:response) { double('response') }
+      let(:adapted_response) { double('adapted response') }
+
+      context 'for a GET request' do
+        it 'should make a GET request and return the response' do
+          HTTParty.should_receive(:get).
+            with(host + path, {:query => params, :headers => headers}).
+            and_return(response)
+          ResponseAdapter.should_receive(:new).with(response).and_return(adapted_response)
+          request.execute.should == adapted_response
+        end
+      end
+
+      context 'for a POST request' do
+        let(:method) { 'POST' }
+
+        it 'should make a POST request and return the response' do
+          HTTParty.should_receive(:post).
+            with(host + path, {:body => params.to_json, :headers => headers}).
+            and_return(response)
+          ResponseAdapter.should_receive(:new).with(response).and_return(adapted_response)
+          request.execute.should == adapted_response
+        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"
+      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"
+        end
+      end
+
+      context "when the query (params) does not exists" do
+        let(:params) { {} }
+        it "should be equal to the host followed by the path" do
+          request.full_uri.should == "http://localhost/hello_world"
+        end
+      end
+    end
+  end
+end

data/spec/contracts/response_adapter_spec.rb

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

data/spec/contracts/response_spec.rb

@@ -0,0 +1,114 @@
+module Contracts
+	describe Response do
+    let(:definition) do
+      {
+        'status' => 200,
+        'headers' => {'Content-Type' => 'application/json'},
+        'body' => double('definition body')
+      }
+    end
+
+		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)
+
+				response = described_class.new(definition).instantiate
+				response.status.should == definition['status']
+				response.headers.should == definition['headers']
+				response.body.should == generated_body
+			end
+		end
+
+    describe '#validate' do
+      let(:status) { 200 }
+      let(:headers) { {'Content-Type' => 'application/json', 'Age' => '60'} }
+      let(:fake_response) do
+        double({
+          :status => status,
+          :headers => headers,
+          :body => 'body'
+        })
+      end
+
+      context 'when status, headers and body match' do
+        it 'should not return any errors' do
+          JSON::Validator.should_receive(:fully_validate).
+            with(definition['body'], fake_response.body).
+            and_return([])
+
+          response = described_class.new(definition)
+          response.validate(fake_response).should == []
+        end
+      end
+      context 'when status, headers and body match' do
+        it 'should not return any errors' do
+          JSON::Validator.should_receive(:fully_validate).
+            with(definition['body'], fake_response.body).
+            and_return([])
+
+          response = described_class.new(definition)
+          response.validate(fake_response).should == []
+        end
+      end
+
+      context 'when status does not match' do
+        let(:status) { 500 }
+
+        it 'should return a status error' do
+          JSON::Validator.stub!(:fully_validate).and_return([])
+
+          response = described_class.new(definition)
+          response.validate(fake_response).should == ["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
+          JSON::Validator.stub!(:fully_validate).and_return([])
+
+          response = described_class.new(definition)
+          response.validate(fake_response).should == ["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
+          JSON::Validator.stub!(:fully_validate).and_return([])
+
+          response = described_class.new(definition)
+          response.validate(fake_response).should == []
+        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
+          JSON::Validator.stub!(:fully_validate).and_return([])
+
+          response = described_class.new(definition)
+          response.validate(fake_response).should == []
+        end
+      end
+
+      context 'when body does not match' do
+        let(:errors) { [double('error1'), double('error2')] }
+
+        it 'should return a list of errors' do
+          JSON::Validator.stub!(:fully_validate).and_return(errors)
+
+          response = described_class.new(definition)
+          response.validate(fake_response).should == errors
+        end
+      end
+    end
+	end
+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/json/generator/array_attribute_spec.rb

@@ -0,0 +1,42 @@
+module JSON
+  module Generator
+    describe ArrayAttribute do
+      it 'should be a BasicAttribute' do
+        described_class.new(nil).should be_a_kind_of(BasicAttribute)
+      end
+
+      describe '#generate' do
+        context 'with minItems' do
+          it 'should generate an array with two objects of the expected type' do
+            stubbed_item = stub('item', :generate => 'foo')
+            AttributeFactory.should_receive(:create).twice.
+              with('type' => 'dummy_type').
+              and_return(stubbed_item)
+
+            properties = {
+              'type' => 'array',
+              'minItems' => 2,
+              'items' => {
+                'type' => 'dummy_type'
+              }
+            }
+            described_class.new(properties).generate.should ==
+              [stubbed_item.generate, stubbed_item.generate]
+          end
+        end
+
+        context 'without minItems' do
+          it 'should generate an empty array' do
+            properties = {
+              'type' => 'array',
+              'items' => {
+                'type' => 'dummy_type'
+              }
+            }
+            described_class.new(properties).generate.should == []
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/attribute_factory_spec.rb

@@ -0,0 +1,72 @@
+module JSON
+  module Generator
+    describe AttributeFactory do
+      describe '.create' do
+        let(:attribute) { stub('attribute') }
+
+        context 'when type is a string' do
+          let(:properties) { {'type' => 'string'} }
+
+          it 'should create a StringAttribute' do
+            StringAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when type is an object' do
+          let(:properties) { {'type' => 'object'} }
+
+          it 'should create an ObjectAttribute' do
+            ObjectAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when type is an array' do
+          let(:properties) { {'type' => 'array'} }
+
+          it 'should create an ArrayAttribute' do
+            ArrayAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when type is an integer' do
+          let(:properties) { {'type' => 'integer'} }
+
+          it 'should create an IntegerAttribute' do
+            IntegerAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when type is a boolean' do
+          let(:properties) { {'type' => 'boolean'} }
+
+          it 'should create a BooleanAttribute' do
+            BooleanAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when we have an array of types' do
+          let(:properties) { {'type' => ['string', 'boolean']} }
+
+          it 'should create a the default attribute for the first type' do
+            StringAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when there is no type' do
+          let(:properties) { {} }
+
+          it 'should create an EmptyAttribute' do
+            EmptyAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/basic_attribute_spec.rb

@@ -0,0 +1,41 @@
+module JSON
+  module Generator
+    describe BasicAttribute do
+      describe '#generate' do
+        context 'with default value' do
+          let(:properties) { {'default' => stub('default')} }
+
+          it 'should return the default value' do
+            described_class.new(properties).generate.should == properties['default']
+          end
+        end
+      end
+
+      describe '#required?' do
+        context 'when required property is true' do
+          let(:properties) { {'required' => true} }
+
+          it 'should be required' do
+            described_class.new(properties).should be_required
+          end
+        end
+
+        context 'when required property is false' do
+          let(:properties) { {'required' => false} }
+
+          it 'should not be required' do
+            described_class.new(properties).should_not be_required
+          end
+        end
+
+        context 'when required property is not defined' do
+          let(:properties) { {} }
+
+          it 'should not be required' do
+            described_class.new(properties).should_not be_required
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/boolean_attribute_spec.rb

@@ -0,0 +1,17 @@
+module JSON
+  module Generator
+    describe BooleanAttribute do
+      it 'should be a BasicAttribute' do
+        described_class.new(nil).should be_kind_of(BasicAttribute)
+      end
+
+      describe '#generate' do
+        context 'without a default value' do
+          it 'should return the default value' do
+            described_class.new({'type' => 'boolean'}).generate.should == false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/dereferencer_spec.rb

@@ -0,0 +1,72 @@
+module JSON
+  module Generator
+    describe Dereferencer do
+      describe '.dereference' do
+        let(:schema) do
+          {
+            'type' => 'object',
+            'properties' => {
+              'referencer' => referencer
+            },
+            'definitions' => definitions
+          }
+        end
+
+        let(:definitions) { {'referenced' => referenced} }
+
+        let(:referencer) do
+          {
+            'type' => 'object',
+            '$ref' => '#/definitions/referenced'
+          }
+        end
+
+        let(:referenced) do
+          {
+            'properties' => {
+              'message' => { 'type' => 'string' }
+            }
+          }
+        end
+
+        it 'should replace references with concrete definitions' do
+          described_class.dereference(schema).should == {
+            'type' => 'object',
+            'properties' => {
+              'referencer' => {
+                'type' => 'object',
+                'properties' => {
+                  'message' => { 'type' => 'string' }
+                }
+              }
+            }
+          }
+        end
+
+        context 'when the schema does not have any reference', 'but has definitions' do
+          let(:schema) { {'type' => 'object',  'properties' => {}, 'definitions' => {}} }
+
+          it 'should return the original schema without the definitions' do
+            described_class.dereference(schema).should == {'type' => 'object', 'properties' => {}}
+          end
+        end
+
+        context 'when the root element does not have properties' do
+          let(:schema) { {'type' => 'string'} }
+
+          it 'should return the original schema' do
+            described_class.dereference(schema).should == schema
+          end
+        end
+
+        context 'when a referenced definition does not exist' do
+          let(:definitions) { {} }
+
+          it 'should raise a name error' do
+            expect { described_class.dereference(schema) }.to raise_error NameError
+          end
+        end
+      end
+    end
+  end
+end