api-tester 0.1.0 → 1.1.1

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'api-tester/definition/fields/field'
+
+module ApiTester
+  # Class for defining numeric fields in contracts
+  class NumberField < Field
+    def initialize(name:, default_value: 5, required: false)
+      super name: name, default_value: default_value, required: required
+    end
+
+    def negative_boundary_values
+      super +
+        [
+          'string',
+          true,
+          false,
+          {}
+        ]
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# 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
+
+    def initialize(name:, required: false)
+      super name: name, required: required
+      self.fields = []
+    end
+
+    def with_field(new_field)
+      fields << new_field
+      self
+    end
+
+    def subfields?
+      true
+    end
+
+    def default_value
+      obj = {}
+
+      fields.each do |field|
+        obj[field.name] = field.default_value
+      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_value: [], required: false)
+      super name: name, default_value: default_value, required: required
+    end
+
+    def negative_boundary_values
+      super +
+        [
+          'string',
+          123,
+          0,
+          1,
+          {},
+          true,
+          false
+        ]
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# 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
+
+    def initialize(verb:, response:, request:)
+      self.verb = verb
+      self.request = request
+      self.expected_response = response
+    end
+
+    def default_request
+      { method: verb,
+        payload: request.default_payload,
+        headers: request.default_headers }
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# 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 :query_params
+
+    def initialize
+      self.fields = []
+      self.header_fields = []
+      self.query_params = []
+    end
+
+    def add_field(new_field)
+      fields << new_field
+      self
+    end
+
+    def add_query_param(new_query_param)
+      query_params << new_query_param
+      self
+    end
+
+    def default_query
+      query_params.map { |param| "#{param.name}=#{param.default_value}" }.join('&')
+    end
+
+    def add_header_field(new_header)
+      header_fields << new_header
+      self
+    end
+
+    def payload
+      response = {}
+      fields.each do |field|
+        if field.required == true
+          response[field.name] = field.default_value
+        end
+      end
+      response
+    end
+
+    def default_payload
+      payload
+    end
+
+    def default_headers
+      if header_fields != []
+        headers
+      else
+        { content_type: :json, accept: :json }
+      end
+    end
+
+    def headers
+      header_response = {}
+      header_fields.each do |header_field|
+        header_response[header_field.name] = header_field.default_value
+      end
+      header_response
+    end
+
+    def cases
+      boundary_cases = []
+      fields.each do |field|
+        field.negative_boundary_values.each do |value|
+          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:)
+      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

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

data/lib/api-tester/method_case_test.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'api-tester/util/response_evaluator.rb'
+
+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
+
+    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 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 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 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 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
+      true
+    end
+
+    def increment_fields(seen_fields)
+      seen_fields.each(&:seen)
+    end
+
+    def json_parse(body)
+      JSON.parse!(body)
+    rescue JSON::ParserError
+      body
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'api-tester/util/supported_verbs'
+
+module ApiTester
+  # Check verbs not explicitly defined in contract
+  module ExtraVerbs
+    def self.go(contract)
+      reports = []
+
+      contract.endpoints.each do |endpoint|
+        extras = ApiTester::SupportedVerbs.all - endpoint.verbs
+        headers = endpoint.methods[0].request.default_headers
+        extras.each do |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
+
+      reports
+    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: response,
+            payload: payload,
+            expected_response: expected_response,
+            url: url,
+            verb: verb,
+            module_name: 'VerbModule'
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'api-tester/reporter/status_code_report'
+require 'api-tester/method_case_test'
+
+module ApiTester
+  # 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 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
+      end
+      reports
+    end
+
+    def self.order
+      2
+    end
+  end
+
+  # Test layout used by Format module
+  class FormatTest < MethodCaseTest
+    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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'api-tester/reporter/status_code_report'
+require 'api-tester/method_case_test'
+
+module ApiTester
+  # 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 description: contract.base_url + endpoint.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
+      reports
+    end
+
+    def self.order
+      1
+    end
+  end
+
+  # Test layout used by module
+  class GoodCaseTest < MethodCaseTest
+    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