pacto 0.2.5 → 0.3.0.pre

data/lib/pacto/version.rb

@@ -1,3 +1,3 @@
 module Pacto
-  VERSION = "0.2.5"
+  VERSION = '0.3.0.pre'
 end

data/pacto.gemspec

@@ -19,17 +19,23 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
 
   gem.add_dependency "webmock"
-  gem.add_dependency "json"
-  gem.add_dependency "json-schema", "1.0.4"
+  gem.add_dependency "multi_json"
+  gem.add_dependency "json-schema", "~> 2.0"
   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_dependency "json-schema-generator"
 
   gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"
+  gem.add_development_dependency "should_not"
+  gem.add_development_dependency "aruba"
   gem.add_development_dependency "guard-rspec"
+  gem.add_development_dependency "rubocop"
+  gem.add_development_dependency "guard-rubocop"
+  gem.add_development_dependency "guard-cucumber"
   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/resources/contract_schema.json

@@ -0,0 +1,216 @@
+{
+  "title": "Example Schema",
+  "type": "object",
+  "properties": {
+    "request": {
+      "type": "object",
+      "required": true,
+      "properties": {
+        "method": {
+          "type": "string",
+          "required": true          
+        },
+        "path": {
+          "type": "string",
+          "required": true
+        },
+        "headers": {
+          "type": "object",
+          "required": false
+        },
+        "params": {   
+          "type": "object",
+          "required": false
+        }
+      }
+    },
+    "response": {
+      "type": "object",
+      "required": true,
+      "properties": {
+        "status":{
+          "type": "integer",
+          "required": true
+        },
+        "body": {
+          "$ref": "http://json-schema.org/draft-03/schema#"
+        }
+      }
+    },
+    "json-schema": {
+      "_comment": "this should be refactored to not need the whole schema here",
+      "$schema": "http://json-schema.org/draft-03/schema#",
+      "id": "http://json-schema.org/draft-03/schema#",
+      "type": "object",
+
+      "properties": {
+          "type": {
+              "type": [ "string", "array" ],
+              "items": {
+                  "type": [ "string", { "$ref": "#" } ]
+              },
+              "uniqueItems": true,
+              "default": "any"
+          },
+
+          "properties": {
+              "type": "object",
+              "additionalProperties": { "$ref": "#" },
+              "default": {}
+          },
+
+          "patternProperties": {
+              "type": "object",
+              "additionalProperties": { "$ref": "#" },
+              "default": {}
+          },
+
+          "additionalProperties": {
+              "type": [ { "$ref": "#" }, "boolean" ],
+              "default": {}
+          },
+
+          "items": {
+              "type": [ { "$ref": "#" }, "array" ],
+              "items": { "$ref": "#" },
+              "default": {}
+          },
+
+          "additionalItems": {
+              "type": [ { "$ref": "#" }, "boolean" ],
+              "default": {}
+          },
+
+          "required": {
+              "type": "boolean",
+              "default": false
+          },
+
+          "dependencies": {
+              "type": "object",
+              "additionalProperties": {
+                  "type": [ "string", "array", { "$ref": "#" } ],
+                  "items": {
+                      "type": "string"
+                  }
+              },
+              "default": {}
+          },
+
+          "minimum": {
+              "type": "number"
+          },
+
+          "maximum": {
+              "type": "number"
+          },
+
+          "exclusiveMinimum": {
+              "type": "boolean",
+              "default": false
+          },
+
+          "exclusiveMaximum": {
+              "type": "boolean",
+              "default": false
+          },
+
+          "minItems": {
+              "type": "integer",
+              "minimum": 0,
+              "default": 0
+          },
+
+          "maxItems": {
+              "type": "integer",
+              "minimum": 0
+          },
+
+          "uniqueItems": {
+              "type": "boolean",
+              "default": false
+          },
+
+          "pattern": {
+              "type": "string",
+              "format": "regex"
+          },
+
+          "minLength": {
+              "type": "integer",
+              "minimum": 0,
+              "default": 0
+          },
+
+          "maxLength": {
+              "type": "integer"
+          },
+
+          "enum": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true
+          },
+
+          "default": {
+              "type": "any"
+          },
+
+          "title": {
+              "type": "string"
+          },
+
+          "description": {
+              "type": "string"
+          },
+
+          "format": {
+              "type": "string"
+          },
+
+          "divisibleBy": {
+              "type": "number",
+              "minimum": 0,
+              "exclusiveMinimum": true,
+              "default": 1
+          },
+
+          "disallow": {
+              "type": [ "string", "array" ],
+              "items": {
+                  "type": [ "string", { "$ref": "#" } ]
+              },
+              "uniqueItems": true
+          },
+
+          "extends": {
+              "type": [ { "$ref": "#" }, "array" ],
+              "items": { "$ref": "#" },
+              "default": {}
+          },
+
+          "id": {
+              "type": "string",
+              "format": "uri"
+          },
+
+          "$ref": {
+              "type": "string",
+              "format": "uri"
+          },
+
+          "$schema": {
+              "type": "string",
+              "format": "uri"
+          }
+      },
+
+      "dependencies": {
+          "exclusiveMinimum": "minimum",
+          "exclusiveMaximum": "maximum"
+      },
+
+      "default": {}
+  }
+  }
+}

data/spec/coveralls_helper.rb

@@ -0,0 +1,10 @@
+unless ENV['NO_COVERAGE']
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+  SimpleCov.start
+end

data/spec/integration/data/strict_contract.json

@@ -0,0 +1,33 @@
+{
+  "request": {
+    "method": "GET",
+    "path": "/strict",
+    "headers": {
+      "Accept": "application/json"
+    },
+    "params": {}
+  },
+
+  "response": {
+    "status": 200,
+    "headers": { "Content-Type": "application/json" },
+    "body": {
+      "type": "object",
+      "required": true,
+      "properties": {
+        "devices": {
+            "type": "array",
+            "minItems": 2,
+            "items": {
+              "type": "string",
+              "required": true,
+              "default": "/dev/<%= device_id %>",
+              "pattern": "^/dev/[^/]+(/[^/]+)*$"
+            },
+            "required": true,
+            "uniqueItems": true
+        }
+      }
+    }
+  }
+}

data/spec/integration/data/templating_contract.json

@@ -0,0 +1,25 @@
+{
+  "request": {
+    "method": "GET",
+    "path": "/echo",
+    "headers": {
+      "Accept": "application/json",
+      "Custom-Auth-Token": "<%= auth_token %>",
+      "X-Message": "<%= key %>"
+    },
+    "params": {
+    }
+  },
+
+  "response": {
+    "status": 200,
+    "headers": { "Content-Type": "application/json" },
+    "body": {
+      "type": "object",
+      "required": true,
+      "properties": {
+        "message": { "type": "string", "default": "<%= req['HEADERS']['X-Message'].reverse %>", "required": true }
+      }
+    }
+  }
+}

data/spec/integration/e2e_spec.rb

@@ -1,5 +1,6 @@
 describe 'Pacto' do
   let(:contract_path) { 'spec/integration/data/simple_contract.json' }
+  let(:strict_contract_path) { 'spec/integration/data/strict_contract.json' }
 
   before :all do
     WebMock.allow_net_connect!
@@ -7,7 +8,7 @@ describe 'Pacto' do
 
   context 'Contract validation' do
     before :all do
-      @server = DummyServer.new 8000, '/hello', '{"message": "Hello World!"}'
+      @server = Pacto::Server::Dummy.new 8000, '/hello', '{"message": "Hello World!"}'
       @server.start
     end
 
@@ -17,22 +18,54 @@ describe 'Pacto' do
 
     it 'verifies the contract against a producer' do
       contract = Pacto.build_from_file(contract_path, 'http://localhost:8000')
-      contract.validate.should == []
+      expect(contract.validate).to be_empty
     end
   end
 
   context 'Stub generation' do
     it 'generates a stub to be used by a consumer' do
       contract = Pacto.build_from_file(contract_path, 'http://dummyprovider.com')
-      Pacto.register('my_contract', contract)
-      Pacto.use('my_contract')
-      response.keys.should == ['message']
-      response['message'].should be_kind_of(String)
+      Pacto.register_contract(contract, 'my_tag')
+      Pacto.use('my_tag')
+      expect(response.keys).to eq ['message']
+      expect(response['message']).to be_kind_of(String)
     end
 
     let :response do
       raw_response = HTTParty.get('http://dummyprovider.com/hello', headers: {'Accept' => 'application/json' })
-      JSON.parse(raw_response.body)
+      MultiJson.load(raw_response.body)
+    end
+  end
+
+  context 'Journey' do
+    it 'stubs multiple services with a single use' do
+      Pacto.configure do |c|
+        c.strict_matchers = false
+        c.postprocessor = Pacto::ERBProcessor.new
+        c.preprocessor = nil
+        c.register_callback Pacto::Hooks::ERBHook.new
+      end
+
+      # Preprocessor must be off before building!
+      login_contract = Pacto.build_from_file(contract_path, 'http://dummyprovider.com')
+      contract = Pacto.build_from_file(strict_contract_path, 'http://dummyprovider.com')
+      Pacto.configure do |c|
+        c.register_contract login_contract, :default
+        c.register_contract contract, :devices
+      end
+
+      Pacto.use(:devices, {:device_id => 42})
+
+      raw_response = HTTParty.get('http://dummyprovider.com/hello', headers: {'Accept' => 'application/json' })
+      login_response = MultiJson.load(raw_response.body)
+      expect(login_response.keys).to eq ['message']
+      expect(login_response['message']).to be_kind_of(String)
+
+      devices_response = HTTParty.get('http://dummyprovider.com/strict', headers: {'Accept' => 'application/json' })
+      devices_response = MultiJson.load(devices_response.body)
+      expect(devices_response['devices']).to have(2).items
+      expect(devices_response['devices'][0]).to eq '/dev/42'
+      # devices_response['devices'][1].should == '/dev/43'
     end
   end
 end

data/spec/integration/templating_spec.rb

@@ -0,0 +1,55 @@
+require 'securerandom'
+require 'pacto/erb_processor'
+
+describe 'Templating' do
+  let(:contract_path) { 'spec/integration/data/templating_contract.json' }
+
+  let(:key) { SecureRandom.hex }
+  let(:auth_token) { SecureRandom.hex }
+  let :response do
+    contract = Pacto.build_from_file(contract_path, 'http://dummyprovider.com')
+    Pacto.register_contract(contract, 'my_contract')
+    Pacto.use('my_contract', {:key => key, :auth_token => auth_token})
+
+    raw_response = HTTParty.get('http://dummyprovider.com/echo', headers: {
+      'Accept' => 'application/json',
+      'Custom-Auth-Token' => "#{auth_token}",
+      'X-Message' => "#{key}"
+      }
+    )
+    MultiJson.load(raw_response.body)
+  end
+
+  before :each do
+    Pacto.unregister_all!
+  end
+
+  context 'No processing' do
+    it 'does not proccess erb tag' do
+      Pacto.configure do |c|
+        c.preprocessor = nil
+        c.postprocessor = nil
+        c.strict_matchers = false
+        c.register_callback do |contracts, req, res|
+          res
+        end
+      end
+
+      expect(response.keys).to eq ['message']
+      expect(response['message']).to eq("<%= req['HEADERS']['X-Message'].reverse %>")
+    end
+  end
+
+  context 'Post processing' do
+    it 'processes erb on each request' do
+      Pacto.configure do |c|
+        c.preprocessor = nil
+        c.strict_matchers = false
+        c.postprocessor = Pacto::ERBProcessor.new
+      end
+
+      expect(response.keys).to eq ['message']
+      expect(response['message']).to eq(key.reverse)
+    end
+  end
+end