api-tester 1.0.0 → 1.1.1

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

@@ -1,35 +1,52 @@
+# frozen_string_literal: true
+
 require 'api-tester/reporter/status_code_report'
 require 'api-tester/util/supported_verbs'
 
 module ApiTester
-  class Typo
-    def self.go contract
+  # Module checking various not found scenarios
+  module Typo
+    def self.go(contract)
       reports = []
 
       contract.endpoints.each do |endpoint|
-        allowances(endpoint).each do |verbs|
-            reports.concat check_typo_url(endpoint)
+        allowances(endpoint).each do
+          reports.concat check_typo_url(contract.base_url, endpoint)
         end
       end
 
       reports
     end
 
-    def self.check_typo_url endpoint
+    def self.check_typo_url(base_url, endpoint)
       bad_url = "#{endpoint.url}gibberishadsfasdf"
-      bad_endpoint = ApiTester::Endpoint.new "Bad URL", bad_url
-      typo_case = BoundaryCase.new("Typo URL check", {}, {})
-      method = ApiTester::Method.new ApiTester::SupportedVerbs::GET, ApiTester::Response.new(200), ApiTester::Request.new
-      response = bad_endpoint.call method, typo_case.payload, typo_case.headers
+      bad_endpoint = ApiTester::Endpoint.new name: 'Bad URL',
+                                             relative_url: bad_url
+      typo_case = BoundaryCase.new description: 'Typo URL check',
+                                   payload: {},
+                                   headers: {}
+      method = ApiTester::Method.new verb: ApiTester::SupportedVerbs::GET,
+                                     response: ApiTester::Response.new(
+                                       status_code: 200
+                                     ),
+                                     request: ApiTester::Request.new
+      response = bad_endpoint.call base_url: base_url,
+                                   method: method,
+                                   payload: typo_case.payload,
+                                   headers: typo_case.headers
 
-      test = TypoClass.new response, typo_case.payload, endpoint.not_found_response, bad_url, ApiTester::SupportedVerbs::GET
+      test = TypoClass.new response,
+                           typo_case.payload,
+                           endpoint.not_found_response,
+                           bad_url,
+                           ApiTester::SupportedVerbs::GET
       test.check
     end
 
     def self.allowances(endpoint)
       allowances = []
       endpoint.methods.each do |method|
-          allowances << method.verb
+        allowances << method.verb
       end
       allowances.uniq
     end
@@ -39,9 +56,15 @@ module ApiTester
     end
   end
 
+  # Test layout for TypoModule
   class TypoClass < MethodCaseTest
-    def initialize response, payload, expected_response, url, verb
-      super response, payload, expected_response, url, verb, "TypoModule"
+    def initialize(response, payload, expected_response, url, verb)
+      super response: response,
+            payload: payload,
+            expected_response: expected_response,
+            url: url,
+            verb: verb,
+            module_name: 'TypoModule'
     end
   end
 end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'pry'
+
+module ApiTester
+  # Module checking nothing shows up in response which is not defined in contract
+  module UnexpectedFields
+    def self.go(contract)
+      reports = []
+
+      contract.endpoints.each do |endpoint|
+        endpoint.methods.each do |method|
+          default_case = BoundaryCase.new description: 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 = UnexpectedFieldsTest.new response, endpoint.url, method
+          reports.concat test.check
+        end
+      end
+      reports
+    end
+
+    def self.order
+      90
+    end
+  end
+
+  # Test layout for UnexpectedFields module
+  class UnexpectedFieldsTest < 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: 'UnexpectedFieldsModule'
+    end
+
+    def check
+      evaluator = ApiTester::ResponseEvaluator.new actual_body: json_parse(response.body),
+                                                   expected_fields: expected_response
+      response_fields = evaluator.response_field_array
+      expected_fields = evaluator.expected_fields
+      increment_fields evaluator.seen_fields
+      extra = response_fields - expected_fields
+      extra.each do |extra_field|
+        report = Report.new description: "UnexpectedFieldsModule - Found unexpected field #{extra_field}",
+                            url: url,
+                            request: payload,
+                            expected_response: expected_response,
+                            actual_response: response
+        reports << report
+      end
+      reports
+    end
+  end
+end

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

@@ -1,16 +1,22 @@
-require 'api-tester/reporter/missing_response_field_report'
+# frozen_string_literal: true
+
+require 'api-tester/reporter/missing_field_report'
 
 module ApiTester
-  class UnusedFields
-    def self.go contract
+  # Ensures all fields defined in contract are returned during test suite
+  module UnusedFields
+    def self.go(contract)
       reports = []
 
       contract.endpoints.each do |endpoint|
         endpoint.methods.each do |method|
           method.expected_response.body.each do |field|
-            if field.is_seen == 0
-              reports << MissingResponseFieldReport.new(endpoint.url, method.verb, field.name, "UnusedFieldsModule")
-            end
+            next unless field.is_seen.zero?
+
+            reports << MissingFieldReport.new(url: endpoint.url,
+                                              verb: method.verb,
+                                              expected_field: field.name,
+                                              description: 'UnusedFieldsModule')
           end
         end
       end

data/lib/api-tester/reporter/api_report.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'api-tester/reporter/report'
 
 module ApiTester
+  # class for dealing with reports generated by the modules during test suite
   class ApiReport
     attr_accessor :reports
 
@@ -8,31 +11,36 @@ module ApiTester
       self.reports = []
     end
 
-    def add_new url, request, expected_response, actual_response, description="A case"
-      report = Report.new description, url, request, expected_response, actual_response
-      self.reports << report
+    def add_new(url:, request:, expected_response:, actual_response:, description: 'case')
+      report = Report.new description,
+                          url,
+                          request,
+                          expected_response,
+                          actual_response
+      reports << report
     end
 
-    def add_new_report report
-      self.reports << report
+    def add_new_report(report)
+      reports << report
     end
 
-    def add_reports reports
-      self.reports.concat reports
+    def add_reports(reports)
+      reports.each do |report|
+        add_new_report(report)
+      end
     end
 
     def print
-      if self.reports.size > 0
-        puts "Issues discovered: #{self.reports.size}"
-        self.reports.each do |report|
+      if reports.size.zero?
+        puts 'No issues found'
+      else
+        puts "Issues discovered: #{reports.size}"
+        reports.each do |report|
           report.print
-          puts "\n"
-          puts "\n"
+          puts '\n'
+          puts '\n'
         end
-        puts ""
-        puts "Issues discovered: #{self.reports.size}"
-      else
-        puts "No issues found"
+        puts "Total issues: #{reports.size}"
       end
     end
   end

data/lib/api-tester/reporter/missing_field_report.rb

@@ -1,25 +1,24 @@
-module ApiReport
+# frozen_string_literal: true
+
+module ApiTester
+  # Report used for when response is missing a field
   class MissingFieldReport
-    attr_accessor :description
     attr_accessor :url
-    attr_accessor :request
+    attr_accessor :verb
     attr_accessor :expected_field
-    attr_accessor :actual_response
+    attr_accessor :description
 
-    def initialize(description, url, request, expected_field)
-      self.description = description
+    def initialize(url:, verb:, expected_field:, description:)
       self.url = url
-      self.request = request
+      self.verb = verb
       self.expected_field = expected_field
-      self.actual_response = ''
+      self.description = description
     end
 
     def print
-      puts "#{self.description}: "
-      puts "   Requested #{self.url} with payload:"
-      puts "      #{self.request}"
-      puts '   Missing field: '
-      puts "      #{self.expected_field}"
+      puts "#{description}:"
+      puts "   #{verb} #{url} is missing response field:"
+      puts "      #{expected_field}"
     end
   end
 end

data/lib/api-tester/reporter/report.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 module ApiTester
+  # Standard report format for differing responses
   class Report
     attr_accessor :description
     attr_accessor :url
@@ -6,7 +9,7 @@ module ApiTester
     attr_accessor :expected_response
     attr_accessor :actual_response
 
-    def initialize description, url, request, expected_response, actual_response
+    def initialize(description:, url:, request:, expected_response:, actual_response:)
       self.description = description
       self.url = url
       self.request = request
@@ -15,13 +18,13 @@ module ApiTester
     end
 
     def print
-      puts "#{self.description}: "
-      puts "   Requested #{self.url} with payload:"
-      puts "      #{self.request.to_json}"
-      puts "   Expecting: "
-      puts "      " + self.expected_response.to_s
-      puts "   Receiving: "
-      puts "      #{self.actual_response}"
+      puts "#{description}: "
+      puts "   Requested #{url} with payload:"
+      puts "      #{request.to_json}"
+      puts '   Expecting: '
+      puts '      ' + expected_response.to_s
+      puts '   Receiving: '
+      puts "      #{actual_response}"
     end
   end
 end

data/lib/api-tester/reporter/status_code_report.rb

@@ -1,12 +1,19 @@
+# frozen_string_literal: true
+
 require 'api-tester/reporter/report'
 
 module ApiTester
+  # Report for when status code is different than expected
   class StatusCodeReport < Report
     attr_accessor :expected_status_code
     attr_accessor :actual_status_code
 
-    def initialize description, url, request, expected_status_code, actual_status_code
-      super description, url, request, expected_status_code, actual_status_code
+    def initialize(description:, url:, request:, expected_status_code:, actual_status_code:)
+      super description: description,
+            url: url,
+            request: request,
+            expected_response: expected_status_code,
+            actual_response: actual_status_code
       self.expected_status_code = expected_status_code
       self.actual_status_code = actual_status_code
     end

data/lib/api-tester/test_helper.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
+
 module ApiTester
+  # Interface for when things need to be done before or after an api call
   class TestHelper
-    def before
-    end
+    def before; end
 
-    def retrieve_param key
-    end
+    def retrieve_param(key); end
 
-    def after
-    end
+    def after; end
   end
 end

data/lib/api-tester/util/response_evaluator.rb

@@ -1,75 +1,88 @@
+# frozen_string_literal: true
+
 module ApiTester
+  # Class for evaluating responses against what is expected
   class ResponseEvaluator
-      attr_accessor :response_body
-      attr_accessor :expected_response
+    attr_accessor :response_body
+    attr_accessor :expected_response
 
-      def initialize(actual_response_body, expected_response_fields)
-          self.response_body = actual_response_body
-          self.expected_response = expected_response_fields
-      end
+    def initialize(actual_body:, expected_fields:)
+      self.response_body = actual_body
+      self.expected_response = expected_fields
+    end
 
-      def response_field_array
-          field_array self.response_body
-      end
+    def response_field_array
+      field_array response_body
+    end
 
-      def expected_fields
-          expected_fields_hash.keys
-      end
+    def expected_fields
+      expected_fields_hash.keys
+    end
 
-      def seen_fields
-          seen = []
-          fields = response_field_array - extra_fields
-          expected = expected_fields_hash
-          fields.each do |field_key|
-              seen << expected[field_key]
-          end
-          seen
+    def seen_fields
+      seen = []
+      fields = response_field_array - extra_fields
+      expected = expected_fields_hash
+      fields.each do |field_key|
+        seen << expected[field_key]
       end
+      seen
+    end
 
-      def expected_fields_hash
-          expected_field_array self.expected_response.body
-      end
+    def expected_fields_hash
+      expected_field_array expected_response.body
+    end
 
-      def extra_fields
-          response_field_array - expected_fields
-      end
+    def extra_fields
+      response_field_array - expected_fields
+    end
 
-      def missing_fields
-          expected_fields - response_field_array
-      end
+    def missing_fields
+      expected_fields - response_field_array
+    end
 
-      def expected_field_array expected_fields
-          fields = {}
-          expected_fields.each do |field|
-              fields[field.name] = field
-              fields = fields.merge inner_expected_field(field.fields, field.name)
-          end
-          fields
+    def expected_field_array(expected_fields)
+      fields = {}
+      expected_fields.each do |field|
+        fields[field.name] = field
+        fields = fields.merge inner_expected_field(expected_fields: field.fields,
+                                                   name: field.name)
       end
+      fields
+    end
 
-      def inner_expected_field expected_fields, name
-          fields = {}
-          expected_fields.each do |field|
-              inner_name = "#{name}.#{field.name}"
-              fields[inner_name] = field
-              fields = fields.merge inner_expected_field(field.fields, inner_name)
-          end
-          fields
+    def inner_expected_field(expected_fields:, name:)
+      fields = {}
+      expected_fields.each do |field|
+        inner_name = "#{name}.#{field.name}"
+        fields[inner_name] = field
+        fields = fields.merge inner_expected_field(expected_fields: field.fields,
+                                                   name: inner_name)
       end
+      fields
+    end
+
+    def field_array(object)
+      fields = []
 
-      def field_array object
-          fields = []
-          object.each do |key, value|
-              if(value)
-                  fields << key.to_s
-                  fields.concat(field_array(value).map{|i| "#{key}.#{i}"})
-              else
-                  fields.concat(field_array(key))
-              end
-          end
-          fields
-         rescue NoMethodError
-          fields
+      object.each do |key, value|
+        if key.respond_to?('each')
+          fields.concat(field_array(key))
+        elsif value == nil || value == 0 || value == false
+          fields << key.to_s
+          fields.concat(field_array(value).map { |i| "#{key}.#{i}" })
+        elsif value.to_s[0] == '[' && value.to_s[-1] == ']' && !value.to_s.include?('=>')
+          fields << key.to_s
+        elsif value
+          fields << key.to_s
+          fields.concat(field_array(value).map { |i| "#{key}.#{i}" })
+        else
+          fields.concat(field_array(key))
+        end
       end
+      fields
+    rescue NoMethodError
+      fields
+    end
   end
 end