pacto 0.2.5 → 0.3.0.pre

data/spec/unit/pacto/erb_processor_spec.rb

@@ -0,0 +1,23 @@
+module Pacto
+  describe ERBProcessor do
+    subject(:processor) { ERBProcessor.new }
+
+    describe '#process' do
+      let(:erb) { '2 + 2 = <%= 2 + 2 %>' }
+      let(:result) { '2 + 2 = 4' }
+
+      it 'returns the result of ERB' do
+        expect(processor.process(erb)).to eq result
+      end
+
+      it 'logs the erb processed' do
+        Logger.instance.should_receive(:debug).with("Processed contract: \"#{result}\"")
+        processor.process erb
+      end
+
+      it 'does not mess with pure JSONs' do
+        processor.process('{"property": ["one", "two, null"]}')
+      end
+    end
+  end
+end

data/spec/unit/pacto/extensions_spec.rb

@@ -3,30 +3,30 @@ module Pacto
     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'})
+          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 'should return true' do
-            {:a => 'a'}.should be_subset_of({:a => 'a', :b => 'b'})
+          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 'should return false' do
-            {:a => 'a'}.subset_of?({:a => 'b'}).should be_false
+          it 'returns false' do
+            expect({:a => 'a'}.subset_of?({:a => 'b'})).to 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'}
+        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
     end

data/spec/unit/pacto/generator_spec.rb

@@ -0,0 +1,142 @@
+module Pacto
+  describe Generator do
+    let(:record_host) {
+      'http://example.com'
+    }
+    let(:request) do
+      Pacto::Request.new(record_host, {
+        'method' => 'GET',
+        'path' => '/abcd',
+        'headers' => {
+          'Content-Length' => [1234],
+          'Via' => ['Some Proxy'],
+          'User-Agent' => ['rspec']
+        },
+        'params' => []
+      })
+    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')
+        })
+      )
+    end
+    let(:response_body_schema) { '{"message": "dummy generated schema"}' }
+    let(:version) { 'draft3' }
+    let(:schema_generator) { double('schema_generator') }
+    let(:validator) { double('validator') }
+    let(:request_file) { 'request.json' }
+    let(:generator) { described_class.new version, schema_generator, validator }
+
+    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') }
+      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)
+      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')
+          expect { generator.save request_file, request, response_adapter }.to raise_error
+        end
+
+        it 'raises an error if the generated contract is invalid' do
+          JSON::SchemaGenerator.should_receive(:generate).and_return response_body_schema
+          validator.should_receive(:validate).and_raise InvalidContract.new('dummy error')
+          expect { generator.save request_file, request, response_adapter }.to raise_error
+        end
+      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
+          validator.should_receive(:validate).and_return true
+          generator.save request_file, request, response_adapter
+        }
+        subject(:generated_contract) { JSON.parse raw_contract }
+
+        it 'sets the body to the generated json-schema' do
+          expect(subject['response']['body']).to eq(JSON.parse response_body_schema)
+        end
+
+        it 'sets the request attributes' do
+          generated_request = subject['request']
+          expect(generated_request['params']).to eq(request.params)
+          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'
+        end
+
+        it 'normalizes the request method' do
+          generated_request = subject['request']
+          expect(generated_request['method']).to eq(request.method.downcase.to_s)
+        end
+
+        it 'sets the response attributes' do
+          generated_response = subject['response']
+          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
+      end
+    end
+  end
+end

data/spec/unit/pacto/hash_merge_processor_spec.rb

@@ -0,0 +1,20 @@
+module Pacto
+  describe HashMergeProcessor do
+    describe '#process' do
+      let(:response_body_string) { 'a simple string' }
+      let(:response_body_hash) {
+        {'a' => 'simple hash'}
+      }
+
+      it 'does not change contract if values is nil' do
+        expect(subject.process(response_body_string, nil)).to eq response_body_string
+      end
+
+      it 'merges response body with values' do
+        merged_body = {'a' => 'simple hash', 'b' => :key}
+        expect(subject.process(response_body_hash, {:b => :key})).to eq merged_body.to_s
+      end
+
+    end
+  end
+end

data/spec/unit/pacto/logger_spec.rb

@@ -0,0 +1,44 @@
+module Pacto
+  describe Logger do
+    before do
+      logger.log logger_lib
+    end
+
+    subject(:logger) { described_class.instance }
+    let(:logger_lib) { ::Logger.new(StringIO.new) }
+
+    it 'delegates debug to the logger lib' do
+      logger_lib.should_receive(:debug)
+      logger.debug
+    end
+
+    it 'delegates info to the logger lib' do
+      logger_lib.should_receive(:info)
+      logger.info
+    end
+
+    it 'delegates warn to the logger lib' do
+      logger_lib.should_receive(:warn)
+      logger.warn
+    end
+
+    it 'delegates error to the logger lib' do
+      logger_lib.should_receive(:error)
+      logger.error
+    end
+
+    it 'delegates fatal to the logger lib' do
+      logger_lib.should_receive(:error)
+      logger.error
+    end
+
+    it 'has the default log level as error' do
+      expect(logger.level).to eq :error
+    end
+
+    it 'provides access to the log level' do
+      logger.level = :info
+      expect(logger.level).to eq :info
+    end
+  end
+end

data/spec/unit/pacto/meta_schema_spec.rb

@@ -0,0 +1,70 @@
+module Pacto
+  describe MetaSchema do
+    let(:valid_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",
+              "type": "object",
+              "properties": {
+                "message": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        }
+      EOF
+    end
+
+    let(:invalid_contract) do
+      <<-EOF
+        {
+          "request": {
+            "method": "GET",
+            "path": "/hello_world",
+            "headers": {
+              "Accept": "application/json"
+            },
+            "params": {}
+          }
+
+        }
+      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 {
+            schema.validate(valid_contract)
+          }.to_not raise_error(Exception)
+        end
+      end
+
+      context 'with an invalid contract structure' do
+        it 'raises InvalidContract exception' do
+          expect {
+            schema.validate(invalid_contract)
+          }.to raise_error(InvalidContract)
+        end
+      end
+    end
+  end
+end

data/spec/unit/pacto/pacto_spec.rb

@@ -1,23 +1,41 @@
 describe Pacto do
-  let(:contract_name) { 'contract' }
-  let(:contract) { double('contract') }
 
-  after do
-    described_class.unregister_all!
+  around(:each) do |example|
+    $stdout = StringIO.new
+    example.run
+    $stdout = STDOUT
   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
+  def output
+    $stdout.string.strip
+  end
+
+  def mock_validation(errors)
+    expect(JSON::Validator).to receive(:fully_validate).with(any_args).and_return errors
+  end
+
+  describe '.validate_contract' do
+    context 'valid' 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(success).to be_true
       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)
+    context 'invalid' 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(success).to be_false
+      end
+
+      it 'displays several error messages and return false' do
+        mock_validation ['Error 1', 'Error 2']
+        success = Pacto.validate_contract 'my_contract.json'
+        expect(success).to be_false
       end
     end
   end
@@ -35,52 +53,8 @@ describe Pacto do
 
     it 'returns whatever the factory returns' do
       Pacto::ContractFactory.stub(:build_from_file => instantiated_contract)
-      described_class.build_from_file(path, host, file_pre_processor).should == instantiated_contract
+      expect(described_class.build_from_file(path, host, file_pre_processor)).to eq instantiated_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