api-tester 1.0.0 → 1.1.3

data/lib/api-tester/definition/fields/object_field.rb

@@ -1,44 +1,51 @@
+# frozen_string_literal: true
+
 require 'api-tester/definition/fields/field'
 
 module ApiTester
+  # Class for defining objects in a contract
   class ObjectField < Field
-      attr_accessor :fields
+    attr_accessor :fields
 
-      def initialize name:
-          super name: name
-          self.fields = []
-      end
+    def initialize(name:, required: false, has_key: true)
+      super name: name, required: required, has_key: has_key
+      self.fields = []
+    end
 
-      def with_field newField
-          self.fields << newField
-          self
-      end
+    def with_field(new_field)
+      fields << new_field
+      self
+    end
 
-      def has_subfields?
-          true
-      end
+    def subfields?
+      true
+    end
 
-      def default_value
-          obj = Hash.new
+    def type
+      'object'
+    end
 
-          self.fields.each do |field|
-              obj[field.name] = field.default_value
-          end
+    def default
+      obj = {}
 
-          obj
+      fields.each do |field|
+        obj[field.name] = field.default
       end
 
-      def negative_boundary_values
-          super +
-            [
-              "string",
-              [],
-              123,
-              1,
-              0,
-              true,
-              false
-            ]
-      end
+      obj
+    end
+
+    def negative_boundary_values
+      super +
+        [
+          'string',
+          [],
+          123,
+          1,
+          0,
+          true,
+          false
+        ]
+    end
   end
 end

data/lib/api-tester/definition/fields/plain_array_field.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'api-tester/definition/fields/field'
+
+module ApiTester
+  # Class for defining plain arrays
+  class PlainArrayField < Field
+    def initialize(name:, default: [], required: false)
+      super name: name, default: default, required: required
+    end
+
+    def negative_boundary_values
+      super +
+        [
+          'string',
+          123,
+          0,
+          1,
+          {},
+          true,
+          false
+        ]
+    end
+  end
+end

data/lib/api-tester/definition/method.rb

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 module ApiTester
+  # Class for defining methods as part of an endpoint
   class Method
-    attr_accessor :request
-    attr_accessor :expected_response
-    attr_accessor :verb
+    attr_accessor :request, :expected_response, :verb
 
-    def initialize verb, response, request
+    def initialize(verb:, response:, request:)
       self.verb = verb
       self.request = request
       self.expected_response = response
     end
 
     def default_request
-      {:method => self.verb, :payload => request.default_payload, :headers => request.default_headers}
+      { method: verb,
+        payload: request.default_payload,
+        headers: request.default_headers }
     end
   end
 end

data/lib/api-tester/definition/request.rb

@@ -1,30 +1,43 @@
+# frozen_string_literal: true
+
 require 'api-tester/definition/boundary_case'
 
 module ApiTester
+  # Class for defining requests in a contract
   class Request
-    attr_accessor :definition
-    attr_accessor :header_fields
-    attr_accessor :fields
+    attr_accessor :definition, :header_fields, :fields, :query_params
 
     def initialize
       self.fields = []
       self.header_fields = []
+      self.query_params = []
     end
 
     def add_field(new_field)
-      self.fields << new_field
+      fields << new_field
+      self
+    end
+
+    def add_query_param(new_query_param)
+      query_params << new_query_param
       self
     end
 
-    def add_header_field new_header
-      self.header_fields << new_header
+    def default_query
+      query_params.map { |param| "#{param.name}=#{param.default}" }.join('&')
+    end
+
+    def add_header_field(new_header)
+      header_fields << new_header
       self
     end
 
     def payload
-      response = Hash.new
-      self.fields.each do |field|
-        response[field.name] = field.default_value
+      response = {}
+      fields.each do |field|
+        if field.required == true
+          response[field.name] = field.default
+        end
       end
       response
     end
@@ -34,36 +47,47 @@ module ApiTester
     end
 
     def default_headers
-      if self.header_fields != []
-        self.headers
+      if header_fields == []
+        { content_type: :json, accept: :json }
       else
-        {content_type: :json, accept: :json}
+        headers
       end
     end
 
     def headers
       header_response = {}
-      self.header_fields.each do |header|
-        header_response[header.name] = header.default_value
+      header_fields.each do |header_field|
+        header_response[header_field.name] = header_field.default
       end
       header_response
     end
 
     def cases
-      boundary_cases = Array.new
-      self.fields.each do |field|
+      boundary_cases = []
+      fields.each do |field|
         field.negative_boundary_values.each do |value|
-          bcase = BoundaryCase.new("Setting #{field.name} to #{value}", altered_payload(field.name, value), default_headers)
-          boundary_cases.push(bcase)
+          bcase = BoundaryCase.new description: "Setting #{field.name} to #{value}",
+                                   payload: altered_payload(field_name: field.name,
+                                                            value: value),
+                                   headers: default_headers
+          boundary_cases.push bcase
         end
       end
       boundary_cases
     end
 
-    def altered_payload field_name, value
+    def altered_payload(field_name:, value:)
       body = payload
       body[field_name] = value
       body
     end
+
+    def altered_payload_with(fields)
+      body = payload
+      fields.each do |field|
+        body[field[:name]] = field[:value]
+      end
+      body
+    end
   end
 end

data/lib/api-tester/definition/response.rb

@@ -1,36 +1,46 @@
+# frozen_string_literal: true
+
 module ApiTester
+  # Class for defining expected responses
   class Response
-      attr_accessor :code
-      attr_accessor :body
+    attr_accessor :code, :body
 
-      def initialize(status_code=200)
-          self.code = status_code
-          self.body = []
-      end
+    def initialize(status_code: 200)
+      self.code = status_code
+      self.body = []
+    end
 
-      def add_field(new_field)
-          self.body << new_field
-          self
-      end
+    def add_field(new_field)
+      body << new_field
+      self
+    end
 
-      def to_s
-          des = {}
-          self.body.map do |f|
-              des[f.name] = field_display f
-          end
-          des.to_json
+    def to_s
+      des = {}
+      body.map do |f|
+        if f.has_key
+          des[f.name] = field_display f
+        else
+          des = field_display f
+        end
       end
+      des.to_json
+    end
 
-      def field_display field
-          des = field.display_class
-          if field.has_subfields?
-            des = {}
-            field.fields.map do |f|
-              des[f.name] = field_display f
-            end
-            des.to_json
+    def field_display(field)
+      des = field.display_class
+      if field.subfields?
+        des = {}
+        field.fields.map do |f|
+          if f.has_key
+            des[f.name] = field_display f
+          else
+            des = field_display f
           end
-          des
+        end
+        des.to_json
       end
+      des
+    end
   end
 end

data/lib/api-tester/method_case_test.rb

@@ -1,69 +1,83 @@
-require 'api-tester/util/response_evaluator.rb'
+# frozen_string_literal: true
+
+require 'api-tester/util/response_evaluator'
 
 module ApiTester
+  # Class for testing methods
   class MethodCaseTest
-      attr_accessor :expected_response
-      attr_accessor :payload
-      attr_accessor :response
-      attr_accessor :reports
-      attr_accessor :url
-      attr_accessor :module_name
+    attr_accessor :expected_response, :payload, :response, :reports, :url, :module_name
 
-      def initialize response, payload, expected_response, url, verb, module_name
-          self.payload = payload
-          self.response = response
-          self.expected_response = expected_response
-          self.reports = []
-          self.url = "#{verb} #{url}"
-          self.module_name = module_name
-      end
+    def initialize(response:, payload:, expected_response:, url:, verb:, module_name:)
+      self.payload = payload
+      self.response = response
+      self.expected_response = expected_response
+      self.reports = []
+      self.url = "#{verb} #{url}"
+      self.module_name = module_name
+    end
 
-      def response_code_report
-          report = StatusCodeReport.new "#{module_name} - Incorrect response code", self.url, self.payload, self.expected_response.code, self.response.code
-          self.reports << report
-          nil
-      end
+    def response_code_report
+      print 'F'
+      report = StatusCodeReport.new description: "#{module_name} - Incorrect response code",
+                                    url: url,
+                                    request: payload,
+                                    expected_status_code: expected_response.code,
+                                    actual_status_code: "#{response.code} : #{response.body}"
+      reports << report
+      nil
+    end
 
-      def missing_field_report field
-          report = Report.new "#{module_name} - Missing field #{field}", self.url, self.payload, self.expected_response, self.response
-          self.reports << report
-          nil
-      end
+    def missing_field_report(field)
+      print 'F'
+      report = Report.new description: "#{module_name} - Missing field #{field}",
+                          url: url,
+                          request: payload,
+                          expected_response: expected_response,
+                          actual_response: response
+      reports << report
+      nil
+    end
 
-      def extra_field_report field
-          report = Report.new "#{module_name} - Found extra field #{field}", self.url, self.payload, self.expected_response, self.response
-          self.reports << report
-          nil
-      end
+    def extra_field_report(field)
+      print 'F'
+      report = Report.new description: "#{module_name} - Found extra field #{field}",
+                          url: url,
+                          request: payload,
+                          expected_response: expected_response,
+                          actual_response: response
+      reports << report
+      nil
+    end
 
-      def check
-          if check_response_code
-              evaluator = ApiTester::ResponseEvaluator.new json_parse(self.response.body), self.expected_response
-              evaluator.missing_fields.map{|field| missing_field_report(field)}
-              evaluator.extra_fields.map{|field| extra_field_report(field)}
-              increment_fields evaluator.seen_fields
-          end
-          return self.reports
+    def check
+      if check_response_code
+        print '.'
+        evaluator = ApiTester::ResponseEvaluator.new actual_body: json_parse(response.body),
+                                                     expected_fields: expected_response
+        evaluator.missing_fields.map { |field| missing_field_report(field) }
+        evaluator.extra_fields.map { |field| extra_field_report(field) }
+        increment_fields evaluator.seen_fields
       end
+      reports
+    end
 
-      def check_response_code
-          if response.code != expected_response.code
-              response_code_report
-              return false
-          end
-          return true
+    def check_response_code
+      if response && (response.code != expected_response.code)
+        print 'F'
+        response_code_report
+        return false
       end
+      true
+    end
 
-      def increment_fields seen_fields
-          seen_fields.each do |field|
-              field.seen
-          end
-      end
+    def increment_fields(seen_fields)
+      seen_fields.each(&:seen)
+    end
 
-      def json_parse body
-          JSON.parse!(body)
-        rescue JSON::ParserError
-          body
-      end
+    def json_parse(body)
+      JSON.parse!(body)
+    rescue JSON::ParserError
+      body
+    end
   end
 end

data/lib/api-tester/modules/benchmark_module.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'api-tester/reporter/response_time_report'
+
+module ApiTester
+  # Checks the response times collected during the test run
+  # Note: Needs at least one calling module, like GoodCase, to work
+  module BenchmarkModule
+    def self.go(contract)
+      reports = []
+
+      contract.endpoints.each do |endpoint|
+        longest_time = endpoint.longest_time
+        longest_time[:time] = longest_time[:time] * 1000.0 # Convert from seconds to ms
+        if longest_time[:time] > contract.max_time
+          print 'F'
+          reports << ResponseTimeReport.new(url: endpoint.url,
+                                            verb: longest_time[:verb],
+                                            payload: longest_time[:payload],
+                                            max_time: contract.max_time,
+                                            actual_time: longest_time[:time],
+                                            description: 'BenchmarkModule')
+        else
+          print '.'
+        end
+      end
+
+      reports
+    end
+
+    def self.order
+      99
+    end
+  end
+end

data/lib/api-tester/modules/extra_verbs.rb

@@ -1,18 +1,34 @@
- require 'api-tester/util/supported_verbs'
+# frozen_string_literal: true
+
+require 'api-tester/util/supported_verbs'
+require 'api-tester/definition/method'
+require 'api-tester/method_case_test'
 
 module ApiTester
+  # Check verbs not explicitly defined in contract
   module ExtraVerbs
-    def self.go contract
+    def self.go(contract)
       reports = []
 
       contract.endpoints.each do |endpoint|
-        extras = ApiTester::SupportedVerbs.all - endpoint.verbs
+        extras = supported_verbs - endpoint.verbs
         headers = endpoint.methods[0].request.default_headers
         extras.each do |verb|
-          verb_case = BoundaryCase.new("Verb check with #{verb} for #{endpoint.name}", {}, headers)
-          method = ApiTester::Method.new verb, ApiTester::Response.new, ApiTester::Request.new
-          response = endpoint.call method, verb_case.payload, verb_case.headers
-          test = VerbClass.new response, verb_case.payload, endpoint.not_allowed_response, endpoint.url, verb
+          verb_case = BoundaryCase.new description: "Verb check with #{verb} for #{endpoint.name}",
+                                       payload: {},
+                                       headers: headers
+          method = ApiTester::Method.new verb: verb,
+                                         response: ApiTester::Response.new,
+                                         request: ApiTester::Request.new
+          response = endpoint.call base_url: contract.base_url,
+                                   method: method,
+                                   payload: verb_case.payload,
+                                   headers: verb_case.headers
+          test = VerbClass.new response: response,
+                               payload: verb_case.payload,
+                               expected_response: endpoint.not_allowed_response,
+                               url: endpoint.url,
+                               verb: verb
           reports.concat test.check
         end
       end
@@ -20,14 +36,24 @@ module ApiTester
       reports
     end
 
+    def self.supported_verbs
+      ApiTester::SupportedVerbs.all
+    end
+
     def self.order
       3
     end
   end
 
+  # Test template used for module
   class VerbClass < MethodCaseTest
-      def initialize response, payload, expected_response, url, verb
-          super response, payload, expected_response, url, verb, "VerbModule"
-      end
+    def initialize(response:, payload:, expected_response:, url:, verb:)
+      super response: response,
+            payload: payload,
+            expected_response: expected_response,
+            url: url,
+            verb: verb,
+            module_name: 'VerbModule'
+    end
   end
 end

data/lib/api-tester/modules/format.rb

@@ -1,16 +1,26 @@
+# frozen_string_literal: true
+
 require 'api-tester/reporter/status_code_report'
 require 'api-tester/method_case_test'
 
 module ApiTester
-  class Format
-    def self.go contract
+  # Checks the format constraints defined in contract
+  module Format
+    def self.go(contract)
       reports = []
       contract.endpoints.each do |endpoint|
         endpoint.methods.each do |method|
           cases = method.request.cases
           cases.each do |format_case|
-            response = endpoint.call method, format_case.payload, format_case.headers
-            test = FormatTest.new response, format_case.payload, endpoint.bad_request_response, endpoint.url, method.verb
+            response = endpoint.call base_url: contract.base_url,
+                                     method: method,
+                                     payload: format_case.payload,
+                                     headers: format_case.headers
+            test = FormatTest.new response: response,
+                                  payload: format_case.payload,
+                                  expected_response: endpoint.bad_request_response,
+                                  url: endpoint.url,
+                                  verb: method.verb
             reports.concat test.check
           end
         end
@@ -23,9 +33,15 @@ module ApiTester
     end
   end
 
+  # Test layout used by Format module
   class FormatTest < MethodCaseTest
-      def initialize response, payload, expected_response, url, verb
-          super response, payload, expected_response, url, verb, "FormatModule"
-      end
+    def initialize(response:, payload:, expected_response:, url:, verb:)
+      super response: response,
+            payload: payload,
+            expected_response: expected_response,
+            url: url,
+            verb: verb,
+            module_name: 'FormatModule'
+    end
   end
 end

data/lib/api-tester/modules/good_case.rb

@@ -1,16 +1,26 @@
+# frozen_string_literal: true
+
 require 'api-tester/reporter/status_code_report'
 require 'api-tester/method_case_test'
 
 module ApiTester
-  class GoodCase
-    def self.go contract
+  # Checks the good case as defined in contract
+  module GoodCase
+    def self.go(contract)
       reports = []
 
       contract.endpoints.each do |endpoint|
         endpoint.methods.each do |method|
-          default_case = BoundaryCase.new endpoint.url, method.request.default_payload, method.request.default_headers
-          response = endpoint.call method, default_case.payload, default_case.headers
-          test = GoodCaseTest.new response, endpoint.url, method
+          default_case = BoundaryCase.new description: contract.base_url + endpoint.display_url,
+                                          payload: method.request.default_payload,
+                                          headers: method.request.default_headers
+          response = endpoint.call base_url: contract.base_url,
+                                   method: method,
+                                   payload: default_case.payload,
+                                   headers: default_case.headers
+          test = GoodCaseTest.new response: response,
+                                  url: contract.base_url + endpoint.url,
+                                  method: method
           reports.concat test.check
         end
       end
@@ -18,14 +28,19 @@ module ApiTester
     end
 
     def self.order
-        1
+      1
     end
   end
 
-
+  # Test layout used by module
   class GoodCaseTest < MethodCaseTest
-      def initialize response, url, method
-          super response, method.request.default_payload, method.expected_response, url, method.verb, "GoodCaseModule"
-      end
+    def initialize(response:, url:, method:)
+      super response: response,
+            payload: method.request.default_payload,
+            expected_response: method.expected_response,
+            url: url,
+            verb: method.verb,
+            module_name: 'GoodCaseModule'
+    end
   end
 end