airborne-rails 0.99.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1a75ecbbfe8a614852a6d113d03254eed84d26d0e0715e70d051335090610bd
+  data.tar.gz: cbf2103b4072492d434988e02dba5ed3bda47cc515a77b16867f2c1037be0975
+SHA512:
+  metadata.gz: b88e1bdcc2daa43b7386695480a35da4a31573c367b4ca4b910f1f74b8346a4bd6b2232ce66e1352a0caf5b7067dd71a6ce01392b4040bd931cde088fc12ce4a
+  data.tar.gz: e31ba52e1d369cf0f19087dc7b1efa87b3b963627ef8dabdcb491a804e19318ed031d796f3fbb661a14471ef922411da304bcb8ee9d00f474caea2e653cdf36c

data/lib/airborne/expectations.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Airborne
+  # rubocop:todo Metrics/ModuleLength
+  module Expectations
+    def expect_json_types(*args)
+      call_with_path(args) do |param, body|
+        expect_json_types_impl(param, body)
+      end
+    end
+
+    def expect_json(*args)
+      call_with_path(args) do |param, body|
+        expect_json_impl(param, body)
+      end
+    end
+
+    def expect_json_keys(*args)
+      call_with_path(args) do |param, body|
+        expect(body.keys).to include(*param)
+      end
+    end
+
+    def expect_json_sizes(*args)
+      args.push(convert_expectations_for_json_sizes(args.pop))
+
+      expect_json_types(*args)
+    end
+
+    def expect_status(code)
+      code = Rack::Utils::SYMBOL_TO_STATUS_CODE[code] if code.is_a?(Symbol)
+
+      expect(response.code.to_s).to eq(code.to_s)
+    end
+
+    def expect_header(key, content)
+      expect_header_impl(key, content)
+    end
+
+    def expect_header_contains(key, content)
+      expect_header_impl(key, content, true)
+    end
+
+    private
+
+    def get_by_path(...)
+      PathMatcher.call(...)
+    end
+
+    def expect_header_impl(key, content, contains = nil)
+      header = headers[key]
+      raise RSpec::Expectations::ExpectationNotMetError, "Header #{key} not present in the HTTP response" unless header
+
+      if contains
+        expect(header.downcase).to include(content.downcase)
+      else
+        expect(header.downcase).to eq(content.downcase)
+      end
+    end
+
+    # rubocop:todo Metrics/AbcSize
+    # rubocop:todo Metrics/CyclomaticComplexity
+    # rubocop:todo Metrics/MethodLength
+    # rubocop:todo Metrics/PerceivedComplexity
+    def expect_json_impl(expected, actual)
+      actual = actual.to_s if expected.is_a?(Regexp)
+
+      return expect(actual).to match(expected) if property?(expected)
+
+      keys = []
+
+      keys << expected.keys if match_expected?
+      keys << actual.keys if match_actual?
+      keys = expected.keys & actual.keys if match_none?
+
+      keys.flatten.uniq.each do |prop|
+        expected_value = extract_expected_value(expected, prop)
+        actual_value = extract_actual(actual, prop)
+
+        next expect_json_impl(expected_value, actual_value) if hash?(expected_value) && hash?(actual_value)
+        next expected_value.call(actual_value) if expected_value.is_a?(Proc)
+        next expect(actual_value.to_s).to match(expected_value) if expected_value.is_a?(Regexp)
+
+        expect(actual_value).to eq(expected_value)
+      end
+    end
+
+    def expect_json_types_impl(expected, actual)
+      @mapper ||= get_mapper
+
+      actual = convert_to_date(actual) if (expected == :date) || (expected == :date_or_null)
+
+      return expect_type(expected, actual) if expected.is_a?(Symbol)
+      return expected.call(actual) if expected.is_a?(Proc)
+
+      keys = []
+
+      keys << expected.keys if match_expected?
+      keys << actual.keys if match_actual?
+      keys = expected.keys & actual.keys if match_none?
+
+      keys.flatten.uniq.each do |prop|
+        type = extract_expected_type(expected, prop)
+        value = extract_actual(actual, prop)
+        value = convert_to_date(value) if (type == :date) || (type == :date_or_null)
+
+        next expect_json_types_impl(type, value) if hash?(type)
+        next type.call(value) if type.is_a?(Proc)
+
+        type_string = type.to_s
+
+        if type_string.include?("array_of") && !(type_string.include?("or_null") && value.nil?)
+          check_array_types(value, prop, type)
+        else
+          expect_type(type, value, prop)
+        end
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
+
+    def call_with_path(args)
+      if args.length == 2
+        get_by_path(args[0], json_body) do |json_chunk|
+          yield(args[1], json_chunk)
+        end
+      else
+        yield(args[0], json_body)
+      end
+    end
+
+    def extract_expected_value(expected, prop)
+      raise unless expected.key?(prop)
+
+      expected[prop]
+    rescue StandardError
+      raise ExpectationError, "Expectation is expected to contain property: #{prop}"
+    end
+
+    def extract_expected_type(expected, prop)
+      type = expected[prop]
+      type.nil? ? raise : type
+    rescue StandardError
+      raise ExpectationError, "Expectation is expected to contain property: #{prop}"
+    end
+
+    def extract_actual(actual, prop)
+      actual[prop]
+    rescue StandardError
+      raise ExpectationError, "Expected #{actual.class} #{actual}\nto be an object with property #{prop}"
+    end
+
+    def expect_type(expected_type, value, prop_name = nil)
+      raise ExpectationError, "Expected type #{expected_type}\nis an invalid type" if @mapper[expected_type].nil?
+
+      insert = prop_name.nil? ? "" : "#{prop_name} to be of type"
+      message = "Expected #{insert} #{expected_type}\n got #{value.class} instead"
+
+      expect(@mapper[expected_type].any? { |type| value.is_a?(type) }).to eq(true), message
+    end
+
+    def convert_to_date(value)
+      DateTime.parse(value)
+    rescue StandardError
+      nil
+    end
+
+    def check_array_types(value, prop_name, expected_type)
+      expect_array(value, prop_name, expected_type)
+      value.each do |val|
+        expect_type(expected_type, val, prop_name)
+      end
+    end
+
+    def hash?(hash)
+      hash.is_a?(Hash)
+    end
+
+    def expect_array(value, prop_name, expected_type)
+      expect(value.class).to eq(Array),
+                             "Expected #{prop_name}\n to be of type #{expected_type}\n got #{value.class} instead"
+    end
+
+    def convert_expectations_for_json_sizes(old_expectations)
+      return convert_expectation_for_json_sizes(old_expectations) unless old_expectations.is_a?(Hash)
+
+      old_expectations.each_with_object({}) do |(prop_name, expected_size), memo|
+        new_value = if expected_size.is_a?(Hash)
+                      convert_expectations_for_json_sizes(expected_size)
+                    else
+                      convert_expectation_for_json_sizes(expected_size)
+                    end
+        memo[prop_name] = new_value
+      end
+    end
+
+    def convert_expectation_for_json_sizes(expected_size)
+      ->(data) { expect(data.size).to eq(expected_size) }
+    end
+
+    def property?(expectation)
+      [String, Regexp, Float, Integer, TrueClass, FalseClass, NilClass, Array].any? { |type| expectation.is_a?(type) }
+    end
+
+    def get_mapper # rubocop:todo Metrics/MethodLength
+      base_mapper = {
+        integer: [Integer],
+        array_of_integers: [Integer],
+        int: [Integer],
+        array_of_ints: [Integer],
+        float: [Float, Integer],
+        array_of_floats: [Float, Integer],
+        string: [String],
+        array_of_strings: [String],
+        boolean: [TrueClass, FalseClass],
+        array_of_booleans: [TrueClass, FalseClass],
+        bool: [TrueClass, FalseClass],
+        array_of_bools: [TrueClass, FalseClass],
+        object: [Hash],
+        array_of_objects: [Hash],
+        array: [Array],
+        array_of_arrays: [Array],
+        date: [DateTime],
+        null: [NilClass]
+      }
+
+      mapper = base_mapper.clone
+      base_mapper.each do |key, value|
+        mapper[:"#{key}_or_null"] = value + [NilClass]
+      end
+      mapper
+    end
+
+    def match_none?
+      !match_actual? && !match_expected?
+    end
+
+    def match_actual?
+      RSpec.configuration.airborne_match_actual?
+    end
+
+    def match_expected?
+      RSpec.configuration.airborne_match_expected?
+    end
+  end
+end

data/lib/airborne/helpers.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Airborne
+  module Helpers
+    def response
+      @response
+    end
+
+    def headers
+      response
+        .headers
+        .transform_keys { |k| k.to_s.underscore.to_sym }
+        .with_indifferent_access
+    end
+
+    def body
+      response.body
+    end
+
+    def json_body
+      JSON.parse(response.body, symbolize_names: true)
+    rescue StandardError
+      raise InvalidJsonError, "API request returned invalid json"
+    end
+  end
+end

data/lib/airborne/path_matcher.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Airborne
+  class PathMatcher
+    ALL = "?"
+    ANY = "*"
+
+    def self.call(...)
+      new.call(...)
+    end
+
+    # rubocop:todo Metrics/AbcSize,Metrics/MethodLength
+    def call(path, json, &)
+      raise PathError, "Invalid Path, contains '..'" if path.include?("..")
+
+      type = false
+      parts = path.split(".")
+      parts.each_with_index do |part, index|
+        if [ALL, ANY].include?(part)
+          ensure_array(path, json)
+          type = part
+
+          if index < parts.length.pred
+            walk_with_path(type, index, path, parts, json, &)
+            return # rubocop:todo Lint/NonLocalExitFromIterator
+          end
+
+          next
+        end
+
+        json = process_json(part, json)
+      end
+
+      if type == ANY
+        expect_all(json, &)
+      elsif type == ALL
+        expect_one(path, json, &)
+      else
+        yield json
+      end
+    end
+    # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
+
+    private
+
+    # rubocop:todo Metrics/MethodLength
+    def walk_with_path(type, index, path, parts, json, &)
+      last_error = nil
+      item_count = json.length
+      error_count = 0
+      json.each do |element|
+        begin
+          sub_path = parts[(index.next)...(parts.length)].join(".")
+          self.class.call(sub_path, element, &)
+        rescue RSpec::Expectations::ExpectationNotMetError => e
+          last_error = e
+          error_count += 1
+        end
+
+        ensure_match_all(last_error) if type == "*"
+        ensure_match_one(path, item_count, error_count) if type == "?"
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def process_json(part, json)
+      if index?(part) && json.is_a?(Array)
+        json[part.to_i]
+      else
+        json[part.to_sym]
+      end
+    end
+
+    def index?(part)
+      part =~ /^\d+$/
+    end
+
+    def expect_one(path, json)
+      item_count = json.length
+      error_count = 0
+      json.each do |part|
+        yield part
+      rescue RSpec::Expectations::ExpectationNotMetError
+        error_count += 1
+        ensure_match_one(path, item_count, error_count)
+      end
+    end
+
+    def expect_all(json, &)
+      last_error = nil
+      begin
+        json.each(&)
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+        last_error = e
+      end
+      ensure_match_all(last_error)
+    end
+
+    def ensure_match_one(path, item_count, error_count)
+      return unless item_count == error_count
+
+      raise RSpec::Expectations::ExpectationNotMetError,
+            "Expected one object in path #{path} to match provided JSON values"
+    end
+
+    def ensure_match_all(error)
+      raise error unless error.nil?
+    end
+
+    def ensure_array(path, json)
+      return if json.is_a?(Array)
+
+      raise RSpec::Expectations::ExpectationNotMetError,
+            "Expected #{path} to be array got #{json.class} from JSON response"
+    end
+  end
+end

data/lib/airborne/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AirborneRails
+  VERSION = "0.99.0"
+end

data/lib/airborne.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "airborne/path_matcher"
+require "airborne/helpers"
+require "airborne/expectations"
+
+module Airborne
+  class InvalidJsonError < StandardError; end
+  class PathError < StandardError; end
+  class ExpectationError < StandardError; end
+end
+
+RSpec.configure do |config|
+  config.add_setting :airborne_match_expected
+  config.add_setting :airborne_match_actual
+
+  config.before do |e|
+    config.airborne_match_expected =
+      e.metadata[:airborne_match_expected].nil? ? true : e.metadata[:airborne_match_expected]
+    config.airborne_match_actual =
+      e.metadata[:airborne_match_actual].nil? ? false : e.metadata[:airborne_match_actual]
+  end
+
+  config.include Airborne::Helpers
+  config.include Airborne::Expectations
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: airborne-rails
+version: !ruby/object:Gem::Version
+  version: 0.99.0
+platform: ruby
+authors:
+- Placewise Devs
+bindir: bin
+cert_chain: []
+date: 2025-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email:
+- mpc.dev@placewise.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/airborne.rb
+- lib/airborne/expectations.rb
+- lib/airborne/helpers.rb
+- lib/airborne/path_matcher.rb
+- lib/airborne/version.rb
+homepage: https://github.com/Placewise/airborne-rails
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: RSpec helpers and expectations for Rails-based JSON APIs - extracted from
+  airborne
+test_files: []