pacto 0.3.1 → 0.4.0.rc1

data/resources/contract_schema.json

@@ -1,48 +1,76 @@
 {
   "title": "Example Schema",
   "type": "object",
+  "required": ["request", "response"],
+  "definitions": {
+    "subschema": {
+      "anyOf": [
+        { "$ref": "http://json-schema.org/draft-03/schema#" },
+        { "$ref": "http://json-schema.org/draft-04/schema#" }
+      ]
+    }
+  },
   "properties": {
     "name": {
-      "type": "string",
-      "required": false
+      "type": "string"
     },
     "request": {
       "type": "object",
-      "required": true,
+      "required": ["path"],
       "properties": {
         "method": {
-          "type": "string",
-          "required": true          
+          "_deprecated": true,
+          "type": "string"
+        },
+        "http_method": {
+          "type": "string"
         },
         "path": {
-          "type": "string",
-          "required": true
+          "type": "string"
         },
         "headers": {
-          "type": "object",
-          "required": false
+          "type": "object"
         },
-        "params": {   
-          "type": "object",
-          "required": false
+        "params": {
+          "type": "object"
         },
         "body": {
-          "$ref": "http://json-schema.org/draft-03/schema#"
+          "description": "body is deprecated, use schema",
+          "$ref": "#/definitions/subschema"
+        },
+        "schema": {
+          "$ref": "#/definitions/subschema"
         }
       }
     },
     "response": {
       "type": "object",
-      "required": true,
+      "required": ["status"],
       "properties": {
         "status":{
-          "type": "integer",
-          "required": true
+          "type": "integer"
         },
         "body": {
-          "$ref": "http://json-schema.org/draft-03/schema#"
+          "description": "body is deprecated, use schema",
+          "$ref": "#/definitions/subschema"
+        },
+        "schema": {
+          "$ref": "#/definitions/subschema"
+        }
+      }
+    },
+    "examples": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "required": ["request", "response"],
+        "properties": {
+          "request": {
+          },
+          "response": {
+          }
         }
       }
     }
   }
-}
+}

data/resources/draft-04.json

@@ -0,0 +1,150 @@
+{
+    "id": "http://json-schema.org/draft-04/schema#",
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "Core schema meta-schema",
+    "definitions": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#" }
+        },
+        "positiveInteger": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "positiveIntegerDefault0": {
+            "allOf": [ { "$ref": "#/definitions/positiveInteger" }, { "default": 0 } ]
+        },
+        "simpleTypes": {
+            "enum": [ "array", "boolean", "integer", "null", "number", "object", "string" ]
+        },
+        "stringArray": {
+            "type": "array",
+            "items": { "type": "string" },
+            "minItems": 1,
+            "uniqueItems": true
+        }
+    },
+    "type": "object",
+    "properties": {
+        "id": {
+            "type": "string",
+            "format": "uri"
+        },
+        "$schema": {
+            "type": "string",
+            "format": "uri"
+        },
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": {},
+        "multipleOf": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "maximum": {
+            "type": "number"
+        },
+        "exclusiveMaximum": {
+            "type": "boolean",
+            "default": false
+        },
+        "minimum": {
+            "type": "number"
+        },
+        "exclusiveMinimum": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxLength": { "$ref": "#/definitions/positiveInteger" },
+        "minLength": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "pattern": {
+            "type": "string",
+            "format": "regex"
+        },
+        "additionalItems": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "items": {
+            "anyOf": [
+                { "$ref": "#" },
+                { "$ref": "#/definitions/schemaArray" }
+            ],
+            "default": {}
+        },
+        "maxItems": { "$ref": "#/definitions/positiveInteger" },
+        "minItems": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "uniqueItems": {
+            "type": "boolean",
+            "default": false
+        },
+        "maxProperties": { "$ref": "#/definitions/positiveInteger" },
+        "minProperties": { "$ref": "#/definitions/positiveIntegerDefault0" },
+        "required": { "$ref": "#/definitions/stringArray" },
+        "additionalProperties": {
+            "anyOf": [
+                { "type": "boolean" },
+                { "$ref": "#" }
+            ],
+            "default": {}
+        },
+        "definitions": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$ref": "#" },
+            "default": {}
+        },
+        "dependencies": {
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$ref": "#" },
+                    { "$ref": "#/definitions/stringArray" }
+                ]
+            }
+        },
+        "enum": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "type": {
+            "anyOf": [
+                { "$ref": "#/definitions/simpleTypes" },
+                {
+                    "type": "array",
+                    "items": { "$ref": "#/definitions/simpleTypes" },
+                    "minItems": 1,
+                    "uniqueItems": true
+                }
+            ]
+        },
+        "allOf": { "$ref": "#/definitions/schemaArray" },
+        "anyOf": { "$ref": "#/definitions/schemaArray" },
+        "oneOf": { "$ref": "#/definitions/schemaArray" },
+        "not": { "$ref": "#" }
+    },
+    "dependencies": {
+        "exclusiveMaximum": [ "maximum" ],
+        "exclusiveMinimum": [ "minimum" ]
+    },
+    "default": {}
+}

data/sample_apis/album/cover_api.rb

@@ -0,0 +1,12 @@
+# -*- encoding : utf-8 -*-
+module AlbumServices
+  class Cover < Grape::API
+    format :json
+    desc 'Ping'
+    namespace :album do
+      get ':id/cover' do
+        { cover: 'image' }
+      end
+    end
+  end
+end

data/sample_apis/config.ru

@@ -0,0 +1,25 @@
+require 'grape'
+require 'grape-swagger'
+require 'json'
+Dir[File.expand_path('../**/*_api.rb', __FILE__)].each do |f|
+    puts "Requiring #{f}"
+  require f
+end
+
+module DummyServices
+  class API < Grape::API
+    prefix 'api'
+    format :json
+    mount DummyServices::Hello
+    mount DummyServices::Ping
+    mount DummyServices::Echo
+    mount DummyServices::Files
+    mount DummyServices::Reverse
+    mount AlbumServices::Cover
+    add_swagger_documentation # api_version: 'v1'
+  end
+end
+DummyServices::API.routes.each do |route|
+  p route
+end
+run DummyServices::API

data/sample_apis/echo_api.rb

@@ -0,0 +1,26 @@
+# -*- encoding : utf-8 -*-
+# This illustrates simple get w/ params and post w/ body services
+# It also illustrates having two services w/ the same endpoint (just different HTTP methods)
+module DummyServices
+  class Echo < Grape::API
+    format :json
+    content_type :txt, 'text/plain'
+
+    helpers do
+      def echo(message)
+        error!('Bad Request', 400) unless message
+        message
+      end
+    end
+
+    # curl localhost:5000/api/echo --get --data-urlencode 'msg={"one fish": "two fish"}' -vv
+    get '/echo' do
+      echo params[:msg]
+    end
+
+    # curl localhost:5000/api/echo -H 'Content-Type: text/plain' -d '{"red fish": "blue fish"}' -vv
+    post '/echo' do
+      echo env['api.request.body']
+    end
+  end
+end

data/sample_apis/files_api.rb

@@ -0,0 +1,50 @@
+# -*- encoding : utf-8 -*-
+# This example should illustrate
+#   - Authentication
+#   - Expect: 100-continue
+#   - Binary data
+#   - Content negotiation
+#   - Etags
+#   - Collections
+module DummyServices
+  class PartialRequestException < StandardError
+    attr_reader :http_status, :msg
+    def initialize(http_status, msg)
+      @http_status = http_status
+      @msg = msg
+    end
+  end
+
+  class Files < Grape::API
+    format :json
+    content_type :binary, 'application/octet-stream'
+    content_type :pdf, 'application/pdf'
+
+    before do
+      error!('Unauthorized', 401) unless env['HTTP_X_AUTH_TOKEN'] == '12345'
+
+      if env['HTTP_EXPECT'] == '100-continue'
+        # Can't use Content-Type because Grape tries to handle it, causing problems
+        case env['CONTENT_TYPE']
+        when 'application/pdf'
+          fail DummyServices::PartialRequestException.new(100, 'Continue')
+        when 'application/webm'
+          fail DummyServices::PartialRequestException.new(415, 'Unsupported Media Type')
+        else
+          fail DummyServices::PartialRequestException.new(417, 'Expectation Failed')
+        end
+      end
+    end
+
+    rescue_from DummyServices::PartialRequestException do |e|
+      Rack::Response.new([], e.http_status, {}).finish
+    end
+
+    namespace '/files' do
+      # curl localhost:5000/api/files/myfile.txt -H 'X-Auth-Token: 12345' -d @myfile.txt -vv
+      put ':name' do
+        params[:name]
+      end
+    end
+  end
+end

data/sample_apis/hello_api.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+#  This illustrates a simple get service
+module DummyServices
+  class Hello < Grape::API
+    format :json
+    content_type :json, 'application/json'
+
+    desc 'Hello'
+    get '/hello' do
+      header 'Vary', 'Accept'
+      { message: 'Hello World!' }
+    end
+  end
+end

data/sample_apis/ping_api.rb

@@ -0,0 +1,11 @@
+# -*- encoding : utf-8 -*-
+#  This illustrates a simple get service
+module DummyServices
+  class Ping < Grape::API
+    format :json
+    desc 'Ping'
+    get '/ping' do
+      { ping: 'pong' }
+    end
+  end
+end

data/sample_apis/reverse_api.rb

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+# This illustrates simple get w/ params and post w/ body services
+# It also illustrates having two services w/ the same endpoint (just different HTTP methods)
+module DummyServices
+  class Reverse < Grape::API
+    format :txt
+
+    helpers do
+      def echo(message)
+        error!('Bad Request', 400) unless message
+        message
+      end
+    end
+
+    # curl localhost:5000/api/echo -H 'Content-Type: application/json' -d '{"red fish": "blue fish"}' -vv
+    post '/reverse' do
+      echo(env['api.request.body']).reverse
+    end
+  end
+end

data/samples/README.md

@@ -0,0 +1,11 @@
+Welcome to the Pacto usage samples!
+
+We have a listing of [sample contracts](contracts/README.html).
+
+Highlighted samples:
+
+- *[Configuration](configuration.html)*: Shows the available Pacto configuration
+- *[Generation](generation.html)*: Shows how to generate Contracts
+- *[RSpec](rspec.html)*: Shows the usage of RSpec expectations for collaboration tests
+
+See the Table of Contents (upper right corner) for a full list of available samples.

data/samples/Rakefile

@@ -0,0 +1,2 @@
+require 'pacto/rake_task' # FIXME: This require turns on WebMock
+WebMock.allow_net_connect!

data/samples/configuration.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+# Just require pacto to add it to your project.
+require 'pacto'
+# Pacto will disable live connections, so you will get an error if
+# your code unexpectedly calls an service that was not stubbed.  If you
+# want to re-enable connections, run `WebMock.allow_net_connect!`
+WebMock.allow_net_connect!
+
+# Pacto can be configured via a block:
+Pacto.configure do |c|
+  # Path for loading/storing contracts.
+  c.contracts_path = 'contracts'
+  # If the request matching should be strict (especially regarding HTTP Headers).
+  c.strict_matchers = true
+  # You can set the Ruby Logger used by Pacto.
+  c.logger = Pacto::Logger::SimpleLogger.instance
+  # (Deprecated) You can specify a callback for post-processing responses.  Note that only one hook
+  # can be active, and specifying your own will disable ERB post-processing.
+  c.register_hook do |_contracts, request, _response|
+    puts "Received #{request}"
+  end
+  # Options to pass to the [json-schema-generator](https://github.com/maxlinc/json-schema-generator) while generating contracts.
+  c.generator_options = { schema_version: 'draft3' }
+end
+
+# You can also do inline configuration.  This example tells the json-schema-generator to store default values in the schema.
+Pacto.configuration.generator_options = { defaults: true }
+
+# If you're using Pacto's rspec matchers you might want to configure a reset between each scenario
+require 'pacto/rspec'
+RSpec.configure do |c|
+  c.after(:each)  { Pacto.clear! }
+end