pacto 0.3.0.pre → 0.3.0

data/spec/unit/pacto/core/validation_spec.rb

@@ -0,0 +1,60 @@
+module Pacto
+  describe Validation do
+    let(:request) { double('request') }
+    let(:response) { double('response') }
+    let(:contract) { double('contract') }
+    let(:validation_results) { double('validation_results') }
+
+    before(:each) do
+      allow(contract).to receive(:validate_consumer)
+    end
+
+    it 'stores the request, response and contract' do
+      validation = Pacto::Validation.new request, response, contract
+      expect(validation.request).to eq request
+      expect(validation.response).to eq response
+    end
+
+    it 'generates and stores the results' do
+      expect(contract).to receive(:validate_consumer).with(request, response).and_return(validation_results)
+      validation = Pacto::Validation.new request, response, contract
+      expect(validation.results).to eq validation_results
+    end
+
+    describe '#successful?' do
+      subject(:validation) do
+        Pacto::Validation.new request, response, contract
+      end
+
+      it 'returns true if there were no validation errors' do
+        expect(validation.successful?).to be_true
+      end
+
+      it 'returns false if there were validation errors' do
+        expect(validation.successful?).to be_true
+      end
+    end
+
+    describe '#against_contract?' do
+      it 'returns nil if there was no contract' do
+        validation = Pacto::Validation.new request, response, nil
+        expect(validation.against_contract? 'a').to be_nil
+      end
+
+      it 'returns the contract with an exact string name match' do
+        allow(contract).to receive(:file).and_return('foo')
+        validation = Pacto::Validation.new request, response, contract
+        expect(validation.against_contract? 'foo').to eq(contract)
+        expect(validation.against_contract? 'bar').to be_nil
+      end
+
+      it 'returns the contract if there is a regex match' do
+        allow(contract).to receive(:file).and_return 'foobar'
+        validation = Pacto::Validation.new request, response, contract
+        expect(validation.against_contract?(/foo/)).to eq(contract)
+        expect(validation.against_contract?(/bar/)).to eq(contract)
+        expect(validation.against_contract?(/baz/)).to be_nil
+      end
+    end
+  end
+end

data/spec/unit/pacto/extensions_spec.rb

@@ -1,32 +1,23 @@
 module Pacto
   module Extensions
     describe HashSubsetOf do
-      describe '#subset_of?' do
-        context 'when the other hash is the same' do
-          it 'returns true' do
-            expect({:a => 'a'}).to be_subset_of({:a => 'a'})
-          end
-        end
-
-        context 'when the other hash is a subset' do
-          it 'returns true' do
-            expect({:a => 'a'}).to be_subset_of({:a => 'a', :b => 'b'})
-          end
-        end
-
-        context 'when the other hash is not a subset' do
-          it 'returns false' do
-            expect({:a => 'a'}.subset_of?({:a => 'b'})).to be_false
-          end
+      describe '#normalize_keys' do
+        it 'turns keys into downcased strings' do
+          expect({:A => 'a'}.normalize_keys).to eq('a' => 'a')
+          expect({:a => 'a'}.normalize_keys).to eq('a' => 'a')
+          expect({'A' => 'a'}.normalize_keys).to eq('a' => 'a')
+          expect({'a' => 'a'}.normalize_keys).to eq('a' => 'a')
         end
       end
 
-      describe '#normalize_keys' do
-        it 'turns keys into downcased strings' do
-          expect({:A => 'a'}.normalize_keys).to eq({'a' => 'a'})
-          expect({:a => 'a'}.normalize_keys).to eq({'a' => 'a'})
-          expect({'A' => 'a'}.normalize_keys).to eq({'a' => 'a'})
-          expect({'a' => 'a'}.normalize_keys).to eq({'a' => 'a'})
+      describe '#normalize_header_keys' do
+        it 'matches headers to the style in the RFC documentation' do
+          expect(Pacto::Extensions.normalize_header_keys(:'user-agent' => 'a')).to eq('User-Agent' => 'a') # rubocop:disable SymbolName
+          expect(Pacto::Extensions.normalize_header_keys(:user_agent => 'a')).to eq('User-Agent' => 'a')
+          expect(Pacto::Extensions.normalize_header_keys('User-Agent' => 'a')).to eq('User-Agent' => 'a')
+          expect(Pacto::Extensions.normalize_header_keys('user-agent' => 'a')).to eq('User-Agent' => 'a')
+          expect(Pacto::Extensions.normalize_header_keys('user_agent' => 'a')).to eq('User-Agent' => 'a')
+          expect(Pacto::Extensions.normalize_header_keys('USER_AGENT' => 'a')).to eq('User-Agent' => 'a')
         end
       end
     end

data/spec/unit/pacto/generator/filters_spec.rb

@@ -0,0 +1,99 @@
+module Pacto
+  class Generator
+    describe Filters do
+      let(:record_host) do
+        'http://example.com'
+      end
+      let(:request) do
+        RequestClause.new(
+          record_host,
+          'method' => 'GET',
+          'path' => '/abcd',
+          'headers' => {
+            'Server' => ['example.com'],
+            'Connection' => ['Close'],
+            'Content-Length' => [1234],
+            'Via' => ['Some Proxy'],
+            'User-Agent' => ['rspec']
+          },
+          'params' => {
+            'apikey' => "<%= ENV['MY_API_KEY'] %>"
+          }
+        )
+      end
+      let(:varies) { ['User-Agent'] }
+      let(:response) do
+        Faraday::Response.new(
+          :status => 200,
+          :response_headers => {
+            'Date' => Time.now.rfc2822,
+            'Last-Modified' => Time.now.rfc2822,
+            'ETag' => 'abc123',
+            'Server' => ['Fake Server'],
+            'Content-Type' => ['application/json'],
+            'Vary' => varies
+          },
+          :body => double('dummy body')
+        )
+      end
+
+      describe '#filter_request_headers' do
+        subject(:filtered_request_headers) { described_class.new.filter_request_headers(request, response).keys.map(&:downcase) }
+        it 'keeps important request headers' do
+          expect(filtered_request_headers).to include 'user-agent'
+        end
+
+        it 'filters informational request headers' do
+          expect(filtered_request_headers).not_to include 'via'
+          expect(filtered_request_headers).not_to include 'date'
+          expect(filtered_request_headers).not_to include 'server'
+          expect(filtered_request_headers).not_to include 'content-length'
+          expect(filtered_request_headers).not_to include 'connection'
+        end
+
+        context 'multiple Vary elements' do
+          context 'as a single string' do
+            let(:varies) do
+              ['User-Agent,Via']
+            end
+            it 'keeps each header' do
+              expect(filtered_request_headers).to include 'user-agent'
+              expect(filtered_request_headers).to include 'via'
+            end
+          end
+          context 'as multiple items' do
+            let(:varies) do
+              %w{User-Agent Via}
+            end
+            it 'keeps each header' do
+              expect(filtered_request_headers).to include 'user-agent'
+              expect(filtered_request_headers).to include 'via'
+            end
+          end
+        end
+      end
+
+      describe '#filter_response_headers' do
+        subject(:filtered_response_headers) { described_class.new.filter_response_headers(request, response).keys.map(&:downcase) }
+        it 'keeps important response headers' do
+          expect(filtered_response_headers).to include 'content-type'
+        end
+
+        it 'filters connection control headers' do
+          expect(filtered_response_headers).not_to include 'content-length'
+          expect(filtered_response_headers).not_to include 'via'
+        end
+
+        it 'filters freshness headers' do
+          expect(filtered_response_headers).not_to include 'date'
+          expect(filtered_response_headers).not_to include 'last-modified'
+          expect(filtered_response_headers).not_to include 'eTag'
+        end
+
+        it 'filters x-* headers' do
+          expect(filtered_response_headers).not_to include 'x-men'
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/generator_spec.rb

@@ -1,73 +1,53 @@
 module Pacto
   describe Generator do
-    let(:record_host) {
+    let(:record_host) do
       'http://example.com'
-    }
+    end
+
     let(:request) do
-      Pacto::Request.new(record_host, {
-        'method' => 'GET',
-        'path' => '/abcd',
-        'headers' => {
+      Faraday::Request.create :get do |req|
+        req.path = '/abcd'
+        req.params = { 'apikey' => "<%= ENV['MY_API_KEY'] %>" }
+        req.headers =  {
           'Content-Length' => [1234],
           'Via' => ['Some Proxy'],
           'User-Agent' => ['rspec']
-        },
-        'params' => []
-      })
+        }
+      end
     end
+
     let(:response_adapter) do
-      Pacto::ResponseAdapter.new(
-        OpenStruct.new({
-          'status' => 200,
-          'headers' => {
-            'Date' => [Time.now],
-            'Server' => ['Fake Server'],
-            'Content-Type' => ['application/json']
-          },
-          'body' => double('dummy body')
-        })
+      Faraday::Response.new(
+        :status => 200,
+        :response_headers => {
+          'Date' => [Time.now],
+          'Server' => ['Fake Server'],
+          'Content-Type' => ['application/json'],
+          'Vary' => ['User-Agent']
+        },
+        :body => 'dummy body' # body is just a string
       )
     end
+    let(:filtered_request_headers) { double('filtered_response_headers') }
+    let(:filtered_response_headers) { double('filtered_response_headers') }
     let(:response_body_schema) { '{"message": "dummy generated schema"}' }
     let(:version) { 'draft3' }
     let(:schema_generator) { double('schema_generator') }
     let(:validator) { double('validator') }
+    let(:filters) { double :filters }
     let(:request_file) { 'request.json' }
-    let(:generator) { described_class.new version, schema_generator, validator }
+    let(:options) { Pacto.configuration.generator_options }
+    let(:generator) { described_class.new version, schema_generator, validator, options, filters }
 
-    def pretty obj
+    def pretty(obj)
       MultiJson.encode(obj, :pretty => true).gsub(/^$\n/, '')
     end
 
-    describe '#generate' do
-      let(:request_contract) {
-        double({
-          :request => request,
-        })
-      }
-      let(:generated_contract) { double('generated contract') }
+    describe '#save' do
       before do
-        Pacto.should_receive(:build_from_file).with(request_file, record_host).and_return request_contract
-        request.should_receive(:execute).and_return response_adapter
-      end
-
-      it 'parses the request' do
-        generator.should_receive(:save).with(request_file, request, anything)
-        generator.generate request_file, record_host
-      end
-
-      it 'fetches a response' do
-        generator.should_receive(:save).with(request_file, anything, response_adapter)
-        generator.generate request_file, record_host
-      end
-
-      it 'saves the result' do
-        generator.should_receive(:save).with(request_file, request, response_adapter).and_return generated_contract
-        expect(generator.generate request_file, record_host).to eq(generated_contract)
+        filters.should_receive(:filter_request_headers).with(request, response_adapter).and_return filtered_request_headers
+        filters.should_receive(:filter_response_headers).with(request, response_adapter).and_return filtered_response_headers
       end
-    end
-
-    describe '#save' do
       context 'invalid schema' do
         it 'raises an error if schema generation fails' do
           JSON::SchemaGenerator.should_receive(:generate).and_raise ArgumentError.new('Could not generate schema')
@@ -82,11 +62,11 @@ module Pacto
       end
 
       context 'valid schema' do
-        let(:raw_contract) {
-          JSON::SchemaGenerator.should_receive(:generate).with(request_file, response_adapter.body, 'draft3').and_return response_body_schema
+        let(:raw_contract) do
+          JSON::SchemaGenerator.should_receive(:generate).with(request_file, response_adapter.body, Pacto.configuration.generator_options).and_return response_body_schema
           validator.should_receive(:validate).and_return true
           generator.save request_file, request, response_adapter
-        }
+        end
         subject(:generated_contract) { JSON.parse raw_contract }
 
         it 'sets the body to the generated json-schema' do
@@ -99,17 +79,9 @@ module Pacto
           expect(generated_request['path']).to eq(request.path)
         end
 
-        it 'keeps important request headers' do
-          saved_headers = subject['request']['headers']
-          expect(saved_headers.keys).to include 'User-Agent'
-        end
-
-        it 'filters informational request headers' do
-          saved_headers = subject['request']['headers']
-          expect(saved_headers).not_to include 'Date'
-          expect(saved_headers).not_to include 'Server'
-          expect(saved_headers).not_to include 'Content-Length'
-          expect(saved_headers).not_to include 'Connection'
+        it 'preserves ERB in the request params' do
+          generated_request = subject['request']
+          expect(generated_request['params']['apikey']).to eq("<%= ENV['MY_API_KEY'] %>")
         end
 
         it 'normalizes the request method' do
@@ -122,17 +94,6 @@ module Pacto
           expect(generated_response['status']).to eq(response_adapter.status)
         end
 
-        it 'keeps important response headers' do
-          saved_headers = subject['response']['headers']
-          expect(saved_headers.keys).to include 'Content-Type'
-        end
-
-        it 'filters informational response headers' do
-          saved_headers = subject['response']['headers']
-          expect(saved_headers).not_to include 'Content-Length'
-          expect(saved_headers).not_to include 'Via'
-        end
-
         it 'generates pretty JSON' do
           expect(raw_contract).to eq(pretty(subject))
         end

data/spec/unit/pacto/meta_schema_spec.rb

@@ -31,7 +31,7 @@ module Pacto
       EOF
     end
 
-    let(:invalid_contract) do
+    let(:partial_contract) do
       <<-EOF
         {
           "request": {
@@ -47,22 +47,62 @@ module Pacto
       EOF
     end
 
+    let(:invalid_contract) do
+      <<-EOF
+        {
+          "request": {
+            "method": "GET",
+            "path": "/hello_world",
+            "headers": {
+              "Accept": "application/json"
+            },
+            "params": {}
+          },
+
+          "response": {
+            "status": 200,
+            "headers": {
+              "Content-Type": "application/json"
+            },
+            "body": {
+              "description": "A simple response",
+              "required": {},
+              "type": "object",
+              "properties": {
+                "message": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        }
+      EOF
+    end
+
     subject(:schema) { MetaSchema.new }
 
     describe 'when validating a contract against the master schema' do
       context 'with a valid contract structure' do
         it 'does not raise any exceptions' do
-          expect {
+          expect do
             schema.validate(valid_contract)
-          }.to_not raise_error(Exception)
+          end.to_not raise_error(Exception)
+        end
+      end
+
+      context 'with an partial contract structure' do
+        it 'raises InvalidContract exception' do
+          expect do
+            schema.validate(invalid_contract)
+          end.to raise_error(InvalidContract)
         end
       end
 
-      context 'with an invalid contract structure' do
+      context 'with an invalid contract' do
         it 'raises InvalidContract exception' do
-          expect {
+          expect do
             schema.validate(invalid_contract)
-          }.to raise_error(InvalidContract)
+          end.to raise_error(InvalidContract)
         end
       end
     end

data/spec/unit/pacto/pacto_spec.rb

@@ -1,5 +1,6 @@
-describe Pacto do
+require 'spec_helper'
 
+describe Pacto do
   around(:each) do |example|
     $stdout = StringIO.new
     example.run
@@ -19,7 +20,7 @@ describe Pacto do
       it 'displays a success message and return true' do
         mock_validation []
         success = Pacto.validate_contract 'my_contract.json'
-        expect(output).to eq 'All contracts successfully meta-validated'
+        expect(output).to eq 'Validating my_contract.json'
         expect(success).to be_true
       end
     end
@@ -28,7 +29,7 @@ describe Pacto do
       it 'displays one error messages and return false' do
         mock_validation ['Error 1']
         success = Pacto.validate_contract 'my_contract.json'
-        expect(output).to match /error/
+        expect(output).to match(/error/)
         expect(success).to be_false
       end
 
@@ -40,21 +41,22 @@ describe Pacto do
     end
   end
 
-  describe '.build_from_file' do
-    let(:path)                  { 'contract/path' }
-    let(:host)                  { 'http://localhost' }
-    let(:file_pre_processor)    { double('file_pre_processor') }
-    let(:instantiated_contract) { double(:instantiated_contract) }
+  describe 'loading contracts' do
+    let(:contracts_path) { 'path/to/dir' }
+    let(:host) { 'localhost' }
+    let(:contract1)  { double }
+    let(:contract2)  { double }
+    let(:factory)  { double(:factory) }
 
-    it 'delegates to ContractFactory' do
-      Pacto::ContractFactory.should_receive(:build_from_file).with(path, host, file_pre_processor)
-      described_class.build_from_file(path, host, file_pre_processor)
+    before do
+      allow(Pacto::ContractFactory).to receive(:new).and_return(factory)
     end
 
-    it 'returns whatever the factory returns' do
-      Pacto::ContractFactory.stub(:build_from_file => instantiated_contract)
-      expect(described_class.build_from_file(path, host, file_pre_processor)).to eq instantiated_contract
+    it 'instantiates a contract list' do
+      allow(Pacto::ContractFiles).to receive(:for).with(contracts_path).and_return { %w{file1 file2} }
+      allow(factory).to receive(:build).with(%w{file1 file2}, host).and_return { [contract1, contract2] }
+      expect(Pacto::ContractList).to receive(:new).with([contract1, contract2])
+      Pacto.load_contracts(contracts_path, host)
     end
   end
-
 end