okapi 0.0.2

data/.gitignore

@@ -0,0 +1,6 @@
+
+*.DS_Store
+*.gem
+/.idea
+/nbproject/
+

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Tu1ly
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,17 @@
+# OKApi
+
+## Installation
+
+    $ gem install okapi
+
+## Usage
+
+    $ okapi help
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/bin/okapi

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..','lib')))
+require 'okapi'
+
+trap(:INT) { abort "" }
+Apiary::Okapi::CLI.new(ARGV)

data/lib/okapi/apiary_connector.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+require 'rest_client'
+require 'json'
+
+module Apiary
+  module Okapi
+    class ApiaryConnector
+
+      attr_reader :apiary_url, :blueprint
+
+      def initialize(apiary_url, req_path, res_path)
+        @apiary_url = apiary_url
+        @req_path = req_path
+        @res_path  = res_path
+      end
+
+      def get_requests(resources, blueprint)
+
+        resources_list = []
+
+        resources.each() do |res|
+          resources_list << {
+            :resource =>  res.uri,
+            :method =>  res.method,
+            :params =>  res.params,
+          }
+        end
+
+        data = {
+          :resources => resources_list,
+          :blueprint => blueprint
+        }.to_json()
+
+        begin
+          response = RestClient.post @apiary_url + @req_path, data, :content_type => :json, :accept => :json
+          data = JSON.parse(response.to_str)
+
+          {:resp => response, :data => data['requests'], :status => data['status'], :error => data['error']}
+        rescue Exception  => e
+          {:resp => nil, :data => nil, :status => nil, :error => e}
+        end
+
+      end
+
+      def get_results(resources, blueprint)
+
+        resources_list = []
+        resources.each() do |res|
+          resources_list << {
+            :request => {
+              :uri =>  res.uri,
+              :expandedUri => res.expanded_uri,
+              :method =>  res.method,
+              :headers =>  res.headers,
+              :body =>  res.body,
+            },
+            :response => {
+              :status =>  res.response.status,
+              :headers => res.response.headers ,
+              :body =>  res.response.body
+            }
+          }
+        end
+
+        data = {
+          :resources => resources_list,
+          :blueprint => blueprint
+        }.to_json()
+
+        begin
+          response = RestClient.post @apiary_url + @res_path, data, :content_type => :json, :accept => :json
+
+          data = JSON.parse(response.to_str)
+
+          {:resp => response, :data => data['requests'], :status => data['status'], :error => data['error']}
+        rescue Exception  => e
+          {:resp => nil, :data => nil, :status => nil, :error => e}
+        end
+      end
+    end
+  end
+end

data/lib/okapi/cli.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+require 'optparse'
+
+module Apiary
+  module Okapi
+    class CLI
+
+      def initialize(args)
+        case args.first
+          when 'help'
+            puts Apiary::Okapi::Help.show
+          when 'version'
+            puts VERSION
+          when 'okapi'
+            puts Apiary::Okapi::Help.okapi
+          else
+            run(parse_options!(args))
+        end
+
+        
+      end
+
+      def run(options)
+        Apiary::Okapi::Test.new(options[:blueprint], options[:test_spec], options[:test_url], options[:output], options[:apiary_url]).run()
+
+      end
+
+      def parse_options!(args)
+        options = {}
+        options_parser = OptionParser.new do |opts|
+          opts.on("-b", "--blueprint BLUEPRINT",
+                  "path to the blueprint (default: " + BLUEPRINT_PATH + " )") do |blueprint|            
+            options[:blueprint] = blueprint
+          end
+
+          opts.on("-t","--test_spec TEST_SPEC",
+                  "path to the test specification (default: " + TEST_SPEC_PATH + " )") do |test_spec|            
+            options[:test_spec] = test_spec
+          end
+
+          opts.on("-o","--output OUTPUT",
+                  "output format (default" + OUTPUT + ")") do |output|
+            options[:output] = output
+          end
+
+          opts.on("-u","--test_url TEST_URL",
+                  "url to test (default" + TEST_URL + ")") do |test_url|
+            options[:test_url] = test_url
+          end
+
+          opts.on("-a","--apiary APIARY",
+                  "apiary url  (default" + APIARY_URL + ")") do |apiary|
+            options[:apiary_url] = apiary
+          end          
+
+        end
+
+        options_parser.parse!
+        options[:blueprint]   ||= BLUEPRINT_PATH
+        options[:test_spec]   ||= TEST_SPEC_PATH
+        options[:output]      ||= OUTPUT
+        options[:test_url]    ||= TEST_URL
+        options[:apiary_url]  ||= APIARY_URL
+
+        raise OptionParser::InvalidOption, 'Blueprint file "' + options[:blueprint] + '" does not exist' if not File.file?(options[:blueprint])
+        raise OptionParser::InvalidOption, 'Test specification file "' + options[:test_spec] + '" does not exist' if not File.file?(options[:test_spec])
+        
+        options
+
+      rescue OptionParser::InvalidOption => e
+        puts e
+        puts Apiary::Okapi::Help.banner
+        exit 1
+      end
+
+    end
+  end
+end

data/lib/okapi/config.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module Apiary
+  module Okapi
+    APIARY_URL = "https://api.apiary.io"
+    GET_REQUESTS_PATH = "/tests/get-requests"
+    GET_RESULTS_PATH = "/tests/get-test-results"
+    BLUEPRINT_PATH = "apiary.apib"
+    TEST_SPEC_PATH = "tests.spec"
+    OUTPUT = 'tap'
+    TEST_URL = "127.0.0.1"
+  end
+end

data/lib/okapi/help.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module Apiary
+  module Okapi
+    class Help
+      def self.show
+        banner
+        options
+      end
+
+      def self.banner
+        puts "\nUsage: okapi [options]"
+        puts "Try 'okapi help' for more information."
+      end
+
+      def self.options
+        puts "\nCurrently available okapi options are:\n\n"
+
+        puts "\t-b, --blueprint             path to the blueprint (default: " + BLUEPRINT_PATH + " )"
+        puts "\t-t, --test_spec             path to the test specification (default: " + TEST_SPEC_PATH + " )"
+        #puts "\t-o, --output                output format (default: " + OUTPUT + ")"
+        puts "\t-u, --test_url              url to test (default: " + TEST_URL + ")"
+        puts "\t-a, --apiary                apiary url  (default: " + APIARY_URL + ")"
+        puts "\n"
+        puts "\thelp                        Show this help"
+        puts "\n"
+        puts "\tversion                     Show version"
+        puts "\n"
+      end
+
+      def self.okapi
+        puts File.read(File.dirname(__FILE__) + '/okapi')
+      end
+    end
+  end
+end

data/lib/okapi/okapi

@@ -0,0 +1,43 @@
+
+                 ,#.@:
+                @;#@@#
+               #+#@#@;
+          :+#;#'+@#@#`
+         @@##@+@;;    ```  ,` ;,;@@@+',`
+        ;@###@@. ,+#@@@@@@@@#@@@@@@@@@@#``
+       #@@:     `,@@#@#@#@@##@@@@@@@'#`+:+:`
+     .#@` #+     ` ::`  :`,.+;#`,``'`@.##:#`+`##;` `
+    '@#  `      ,  #+@#@+':@###@+;+.#@,@#`+`+#@@@#:.
+   +@@`         +  `;#;++`'@@###@@+ @@,@@`#;@@#@#@@@#;+'
+  :@@@@.      `;    ';#+@,##@####@;,@+,@#`:#':#+'@##@@#'@+`
+ `@@@@###; ` '           @;+#@@#@#.@@'@@@``.'` +#:@'@@#@#@#;
+  `,`#+`,#`              `:;#;@#@;.#+;@@#:'`++ ` #.@@@:@,@@@#
+                           `:;##@##@:##@.'+:@#,#`.@#@:@@;@##+`
+                               #,#@+@@@##@##@#+:`#@@#@`+#;##++
+                               @@@@@@@@@@;'@+@#`#.'@@@@``,.,:#,
+                               ####@@@##'`#@'@@`#'#,@@@#    `@#
+                               ;#@@+@@#'+@'@+@#`#@+@@@@@##   #,#
+                                #@@##@#+##:@#@@,'@.@@@` ::   ;#;
+                                '#,#`#@#.'.#@@#+,####` `     `'#
+                                 +     +:;+@@#@#.##@@#.@.    `+`,
+                                  '    `#+###@@@@@#@@@+`.:`  .'#
+                                  @`    ##@#####@:@@##``     #,@
+                                  @#'`   #@@##@#,'### `      @'#
+                                  ###'       @   :##`#;;#,   @.,
+                                  ,+,+ .. `       +#+':  . ``++,
+                                   :':'@;         +;  `,,,   `;
+                                    #; `:          @;#'`;  :+``
+                                                    
+                                    +`  `            '+;' :   .#`
+                                    @@,@+              .+. ; +##;
+                                    ;#,#@              ',+. `@##
+                                    :#:#                
+                                                        `+   .
+                                    ##.#`               +    #
+                                    #+,@.               @    +
+                                    #+ .`               #    `
+                                    :;                  '``  `
+                                                       +##  ###
+                                                      `@@: .##`
+                                                      '##  ##:
+                                                      `#    `

data/lib/okapi/output.rb

@@ -0,0 +1,11 @@
+Dir["#{File.dirname(__FILE__)}/outputs/*.rb"].each { |f|   require(f)  }
+
+module Apiary
+  module Okapi
+    class Output
+      def self.get(output,resources, error)
+        Apiary::Okapi::Outputs.const_get(output.to_s.capitalize).send(:new, resources, error).get()
+      end
+    end
+  end
+end

data/lib/okapi/outputs/base.rb

@@ -0,0 +1,87 @@
+module Apiary
+  module Okapi
+    module Outputs
+      class BaseOutput
+        def initialize(resources, error)
+          @resources = resources
+          @error = error
+          @results = {
+            :count => 0,
+            :give_up => false,
+          }
+          get_results
+        end
+
+        def get          
+          p '------------------------------------------------------------------'
+          p @results[:count].to_s + ' tests'
+          p @results[:give_up][:error].to_s if @results[:give_up]
+          @results[:tests].each { |test|
+            p '########################################'
+            p test[:test_no]
+            p test[:description]
+            if test[:pass]
+              p 'OK'
+            else
+              p "FAILED"
+              p test[:exp]
+            end
+          }
+        end
+
+        def get_results
+
+          @results[:count] = @resources.count
+          @results[:tests] = []
+          if @error
+            @results[:give_up] = {:error => @error}
+          else
+            counter = 0
+            @resources.each { |res|
+              counter += 1
+              test_res = {
+                :test_no=> counter,
+                :pass => (res.validation_result.status and res.response.validation_result.status),
+                :description => res.method + ' ' + res.uri
+                }
+              if not test_res[:pass]
+                test_res[:exp] = {:request => {:pass => false}, :response => {:pass => false}}
+                if res.validation_result.status
+                  test_res[:exp][:request][:pass] = true
+                else
+                  test_res[:exp][:request][:reasons] = get_fail_result(res.validation_result)
+                end
+
+                if res.response.validation_result.status
+                  test_res[:exp][:response][:pass] = true
+                else
+                  test_res[:exp][:response][:reasons] = get_fail_result(res.response.validation_result)
+                end              
+              end
+            @results[:tests] << test_res
+            }
+          end
+        end
+
+        def get_fail_result(result)
+          res = []
+
+          if result.schema
+            result.schema_res["errors"]["length"].times {|i|
+              res << result.schema_res["errors"][i.to_s]["message"]
+            }
+          else
+            if not result.header_pass
+              res << 'Headers does not match'
+            end
+            if not result.body_pass
+              res << 'Body does not match'
+            end
+          end
+          res
+        end
+
+      end
+    end
+  end
+end

data/lib/okapi/outputs/tap.rb

@@ -0,0 +1,39 @@
+require "#{File.dirname(__FILE__)}/base.rb"
+require 'yaml'
+
+module Apiary
+  module Okapi
+   module Outputs
+     class Tap < Apiary::Okapi::Outputs::BaseOutput
+
+       def get
+         puts "TAP version 13"
+         puts "1..#{@results[:count].to_s}"
+         if @results[:give_up]
+             puts "Bail out! #{@results[:give_up][:error].to_s.tr("\n"," ")}"
+             return
+         end
+         @results[:tests].each { |test|
+           if test[:pass]
+             o = 'ok '
+           else
+             o = 'not ok '
+           end
+           puts o + test[:test_no].to_s + ' ' + test[:description]
+           if not test[:pass]
+             error_block(test)
+           end
+         }
+       end
+
+       def error_block(test)
+         test[:exp].to_yaml.split(/\n/).each { |line|
+           puts "  #{line}"
+         }
+         puts "  ..."
+         
+       end
+     end
+   end
+  end
+end

data/lib/okapi/resources.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+module Apiary
+  module Okapi
+    class Resource
+      attr_accessor :uri, :method, :params, :expanded_uri,  :headers, :body, :response, :validation_result
+
+      def initialize(uri, method, params, expanded_uri = nil,  headers = nil, body = nil, response = nil, validation_result = nil)
+        #p uri, method, params
+        @uri          = uri
+        @method       = method
+        @params       = params
+        @expanded_uri = expanded_uri
+        @headers      = headers
+        @body         = body
+        @response     = response
+        @validation_result = validation_result
+      end
+    end
+
+    class Response
+      attr_accessor :status,  :headers, :body, :error, :validation_result
+
+      def initialize(status = nil, headers = nil, body = nil, error = nil, validation_result = nil)
+        @headers      = headers
+        @body         = body
+        @status       = status
+        @error        = error
+        @validation_result = validation_result
+      end
+    end
+
+    class ValidationResult
+      attr_accessor :status, :error, :schema_res , :body_pass, :body_diff, :header_pass, :header_diff
+
+      def status
+        @status ||= get_status
+      end
+
+      def get_status
+#        p '@error and @headerPass and ((@schema and  @schemaPass) or (not @schema and @bodyPass))'
+#
+#        p @error
+#        p @header_pass
+#        p @schemaRes
+#        p schema
+#        p schema_pass
+#        p @body_pass
+#        p '#'
+#        p (not @error and @header_pass and ((schema and  schema_pass) or (not schema and @body_pass)))
+#        p (@header_pass and ((schema and  schema_pass) or (not schema and @body_pass)))
+#        p (((schema and  schema_pass) or (not schema and @body_pass)))
+#        p (((schema and  schema_pass)))
+#        p (((not schema and @bodyPass)))
+#        p (not @error)
+#        p '----'
+#        p @body_diff
+#        p @header_diff
+        return true if not @error and @header_pass and ((schema and  schema_pass) or (not schema and @body_pass))
+        return false
+      end
+
+      def schema
+        !(@schema_res == false)
+      end
+
+      def schema_pass
+        not schema or schema and @schema_res and not @schema_res['errors']
+      end
+
+    end
+  end
+end

data/lib/okapi/spec_parser.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+require 'json'
+
+module Apiary
+  module Okapi
+    class Parser
+
+      attr_reader :data, :resources
+
+      def initialize(spec_path)
+        @data = read_file(spec_path)
+      end
+
+      def resources
+        @resources ||= begin
+          parse_data { |res|
+            raise Exception, 'resource not defined' unless res["resource"]
+            raise Exception, 'method not defined' unless res["method"]
+
+            (@resources ||= []) << Apiary::Okapi::Resource.new(res["resource"], res["method"], res["params"])
+          }
+        @resources
+        end
+      end
+
+      def read_file(path)
+        @data = []
+        File.open(path).each do |line|
+          @data << line
+        end
+        @data
+      end
+
+      def parse_data
+        @data.each { |res|
+          splited = res.split(' ',3)
+          begin
+            splited[2] = JSON.parse splited[2] if splited[2]
+          rescue Exception => e
+            raise Exception, 'can not parse parameters for resource:' + res + "(#{e})"
+          end
+          out = {
+            'resource' => splited[1],
+            'method' => splited[0],
+            'params' => splited[2] || {}
+            }
+          yield out
+        }
+      end
+
+    end
+  end
+end

data/lib/okapi/test.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+require 'rest_client'
+
+module Apiary
+  module Okapi
+    class Test
+      def initialize(blueprint_path, test_spec_path, test_url, output, apiary_url)
+        @blueprint_path = blueprint_path || BLUEPRINT_PATH
+        @test_spec_path = test_spec_path || TEST_SPEC_PATH
+        @test_url       = test_url || TEST_URL
+        @output_format         = output || OUTPUT
+        @apiary_url     = apiary_url || APIARY_URL
+        @req_path       = GET_REQUESTS_PATH
+        @res_path       = GET_RESULTS_PATH
+        @connector = Apiary::Okapi::ApiaryConnector.new(@apiary_url, @req_path, @res_path)
+        @output = []
+        @resources = []
+        @error = nil
+        
+      end
+
+      def run
+        get_output(method(:test))
+      end
+
+      def get_output(test)
+        begin
+          test.call()
+        #change to Exception !!!!
+        #rescue LoadError => e
+        rescue Exception => e
+          @error = e
+          #p @error
+        end
+
+        Apiary::Okapi::Output.get(@output_format, @resources, @error)
+      end
+
+      def test
+        prepare()
+        if not @resources.empty?
+          get_responses
+          evaluate
+        else
+          raise Exception, 'No resources provided'
+        end
+      end
+
+      def prepare
+        resources = parse_test_spec(@test_spec_path)
+        
+        data = get_requests_spec(resources)
+
+        raise Exception, 'Can not get request data from apiary ' + data[:error] || '' if data[:error] or data[:resp].code.to_i != 200
+         
+        data[:data].each do |res|
+          raise Exception, 'Resource error "' + res['error'] + '" for resource "' + res["method"] + ' ' + res["uri"]  + '"' if res['error']
+
+          resources.each do |resource|
+            if resource.uri == res["uri"] and resource.method == res["method"]
+              resource.expanded_uri = res["expandedUri"]
+              resource.body = res["body"]
+              resource.headers = res["headers"]
+              break
+            end
+          end
+        end
+        @resources = resources
+      end
+
+      def blueprint
+        @blueprint ||= parse_blueprint(@blueprint_path)
+      end
+
+      def get_responses
+        @resources.each { |resource|
+          params = {:method => resource.method, :url => @test_url + resource.expanded_uri['url'], :headers => resource.headers || {}}
+          begin            
+            response = RestClient::Request.execute(params)
+
+            raw_headers = response.raw_headers.inject({}) do |out, (key, value)|
+                            out[key] = %w{ set-cookie }.include?(key.downcase) ? value : value.first
+                            out
+                          end
+
+            resource.response =  Apiary::Okapi::Response.new(response.code, raw_headers, response.body)
+          rescue Exception => e
+            raise Exception 'Can not get response for:' + params
+          end
+          }
+
+      end
+
+      def evaluate
+
+        data = @connector.get_results(@resources, blueprint)
+
+        raise Exception, 'Can not get evaluation data from apiary' + data[:error] || '' if data[:resp].code.to_i != 200 or data[:error]
+
+        data[:data].each { |validation|
+          @resources.each { |resource|
+            if validation['resource']['uri'] == resource.uri and validation['resource']['method'] == resource.method
+              resource.validation_result = Apiary::Okapi::ValidationResult.new()
+              resource.validation_result.error = validation['errors']
+              resource.validation_result.schema_res = validation["validations"]['reqSchemaValidations']
+              resource.validation_result.body_pass = !validation["validations"]['reqData']['body']['isDifferent']
+              resource.validation_result.body_diff = validation["validations"]['reqData']['body']['diff']
+              resource.validation_result.header_pass = !validation["validations"]['reqData']['headers']['isDifferent']
+              resource.validation_result.header_diff = validation["validations"]['reqData']['headers']['diff']
+
+              resource.response.validation_result = Apiary::Okapi::ValidationResult.new()
+              resource.response.validation_result.error = validation['errors']
+              resource.response.validation_result.schema_res = validation["validations"]['resSchemaValidations']
+              resource.response.validation_result.body_pass = !validation["validations"]['resData']['body']['isDifferent']
+              resource.response.validation_result.body_diff = validation["validations"]['resData']['body']['diff']
+              resource.response.validation_result.header_pass = !validation["validations"]['resData']['headers']['isDifferent']
+              resource.response.validation_result.header_diff = validation["validations"]['resData']['headers']['diff']
+            end
+
+          }
+        }
+      end      
+
+      def parse_test_spec(test_spec)
+        Apiary::Okapi::Parser.new(test_spec).resources
+      end
+
+      def parse_blueprint(blueprint_path)
+        File.read(blueprint_path)
+      end
+
+      def get_requests_spec(resources)
+        @connector.get_requests(resources, blueprint)
+      end
+
+    end
+  end
+end
+

data/lib/okapi/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+module Apiary
+  module Okapi
+    VERSION = "0.0.2"
+  end
+end

data/lib/okapi.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+require 'rubygems'
+require "okapi/version"
+require "okapi/config"
+require "okapi/output"
+require "okapi/apiary_connector"
+require "okapi/resources"
+require "okapi/spec_parser"
+require "okapi/test"
+require "okapi/cli"
+require "okapi/help"
+
+
+
+
+module Okapi
+
+end

data/okapi.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require File.expand_path('../lib/okapi/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "okapi"
+  spec.version       = Apiary::Okapi::VERSION
+  spec.authors       = ["Tu1ly"]
+  spec.email         = ["tully@apiary.io"]
+  spec.description   = %q{Apiary.io API tester - OKApi allows you to test if your documentation in Apiary Blueprint match your API}
+  spec.summary       = %q{Apiary.io API tester - OKApi allows you to test if your documentation in Apiary Blueprint match your API}
+  spec.homepage      = "http://apiary.io"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "json"
+  spec.add_dependency "rest-client"
+end

data/test_files/apiary.apib

@@ -0,0 +1,57 @@
+HOST: http://www.google.com/
+
+--- aaaaaaa ---
+
+---
+Welcome to the our sample API documentation. All comments can be written in (support [Markdown](http://daringfireball.net/projects/markdown/syntax) syntax)
+---
+
+--
+Shopping Cart Resources
+The following is a section of resources related to the shopping cart
+--
+
+List products added into your shopping-cart. (comment block again in Markdown)
+GET /shopping-cart/{id}
+< 200
+< Content-Type: application/json
+{ "items": [
+{ "url": "/shopping-cart/1", "product":"2ZY48XPZ", "quantity": 1, "name": "New socks", "price": 1.25 }
+] }
+
+Save new products in your shopping cart
+POST /shopping-cart/{id2}
+> Content-Type: application/json
+{ "product":"1AB23ORM", "quantity": 2 }
+< 201
+< Content-Type: application/json
+{ "status": "created", "url": "/shopping-cart/2" }
+
+-- Payment Resources --
+
+This resource allows you to submit payment information to process your *shopping cart* items
+POST /payment
+{ "cc": "12345678900", "cvc": "123", "expiry": "0112" }
+< 200
+{ "receipt": "/payment/receipt/1aaa" }
+
+-- JSON Schema Validations --
+
+POST /shopping-cart/{id2}
+{"request":
+    { "type": "object",
+      "properties": {
+        "product": { "type": "string","format": "alphanumeric" },
+        "quantity": { "type": "integer" }
+      }
+    }
+,
+"response":
+    { "type": "object",
+      "properties": {
+        "product": { "type": "string","format": "alphanumeric" },
+        "status": { "type": "integer" }
+      }
+    }
+}
+

data/test_files/tests.spec

@@ -0,0 +1,2 @@
+POST /shopping-cart/{id2} {"id2": "eee2"}
+POST /payment

data/test_files/tests_1.spec

@@ -0,0 +1,18 @@
+[{
+  "resource": "/shopping-cart/{id}",
+  "method": "GET",
+  "params": {"id": "eee"}
+}
+,
+{
+  "resource": "/shopping-cart/{id2}",
+  "method": "POST",
+  "params": {"id2": "eee2"}
+}
+,
+{
+  "resource": "/payment",
+  "method": "POST",
+  "params": {}
+}
+]

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: okapi
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Tu1ly
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-05-05 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Apiary.io API tester - OKApi allows you to test if your documentation in Apiary Blueprint match your API
+email: 
+- tully@apiary.io
+executables: 
+- okapi
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/okapi
+- lib/okapi.rb
+- lib/okapi/apiary_connector.rb
+- lib/okapi/cli.rb
+- lib/okapi/config.rb
+- lib/okapi/exceptions.rb
+- lib/okapi/help.rb
+- lib/okapi/okapi
+- lib/okapi/output.rb
+- lib/okapi/outputs/base.rb
+- lib/okapi/outputs/tap.rb
+- lib/okapi/resources.rb
+- lib/okapi/spec_parser.rb
+- lib/okapi/test.rb
+- lib/okapi/version.rb
+- okapi.gemspec
+- test_files/apiary.apib
+- test_files/tests.spec
+- test_files/tests_1.spec
+has_rdoc: true
+homepage: http://apiary.io
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Apiary.io API tester - OKApi allows you to test if your documentation in Apiary Blueprint match your API
+test_files: []
+