rspec-oj 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 505fa0b6ec22748476d0b3aa748f36c4b7d1c226dc87403aedadd31442a89122
+  data.tar.gz: aa0aab2919a98dfc9ade03e6ccee638442c059f9068927a18707282cecf55de3
+SHA512:
+  metadata.gz: ed0c980e4e0af0bf1b8174b01f5a2ebb241dcc44e5162cac15fdfe76b2720277c283ef2780f75108af9c283952c15184e4ebb9ff7e10b230374e3fb6681a69b3
+  data.tar.gz: 208ae97dc849e475b628976632e67cc52c2f341919c8186f7044cb75f7048ad23bd7613afeb1f2bf36c926b25d156750a6ce08f2bda2c4524284cece0e3a10be

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2020 Mikael Henriksson
+
+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,341 @@
+# rspec-oj
+
+Easily handle JSON in RSpec and Cucumber
+
+[![Gem Version](https://img.shields.io/gem/v/rspec-oj.svg?style=flat)](http://rubygems.org/gems/rspec-oj)
+[![Build Status](https://img.shields.io/travis/mhenrixon/rspec-oj/master.svg?style=flat)](https://travis-ci.org/mhenrixon/rspec-oj)
+[![Maintainability](https://api.codeclimate.com/v1/badges/e05efd6949d820a0db09/maintainability)](https://codeclimate.com/github/mhenrixon/rspec-oj/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/e05efd6949d820a0db09/test_coverage)](https://codeclimate.com/github/mhenrixon/rspec-oj/test_coverage)
+
+## RSpec
+
+rspec-oj defines five new RSpec matchers:
+
+* `be_json_eql`
+* `include_json`
+* `have_json_path`
+* `have_json_type`
+* `have_json_size`
+
+The new matchers could be used in RSpec as follows:
+
+```ruby
+describe User do
+  let(:user){ User.create!(first_name: "Steve", last_name: "Richert") }
+
+  context "#to_json" do
+    it "includes names" do
+      names = { "first_name": "Steve", "last_name": "Richert" }
+      expect(user).to be_json_eql(names).excluding("friends")
+    end
+
+    it "includes the ID" do
+      expect(user).to have_json_path("id")
+      expect(user).to have_json_type(Integer).at_path("id")
+    end
+
+    it "includes friends" do
+      expect(user).to have_json_size(0).at_path("friends")
+
+      friend = User.create!(first_name: "Catie", last_name: "Richert")
+      user.friends << friend
+
+      expect(user).to have_json_size(1).at_path("friends")
+      expect(user).to include_json(friend)
+    end
+  end
+end
+```
+
+rspec-oj also provides some useful helpers for RSpec tests:
+
+* `parse_json`
+* `normalize_json`
+* `generate_normalized_json`
+* `load_json`
+
+To start using them add an include them in your RSpec configuration:
+
+```ruby
+RSpec.configure do |config|
+  config.include RSpec::Oj::Helpers
+end
+```
+
+You can find usage examples for the helpers in [`spec/rspec/oj/helpers_spec.rb`](https://github.com/mhenrixon/rspec-oj/blob/master/spec/rspec/oj/helpers_spec.rb)
+
+### Exclusions
+
+rspec-oj ignores certain hash keys by default when comparing JSON:
+
+* `id`
+* `created_at`
+* `updated_at`
+
+It's oftentimes helpful when evaluating JSON representations of newly-created ActiveRecord records
+so that the new ID and timestamps don't have to be known. These exclusions are globally
+customizeable:
+
+```ruby
+RSpec::Oj.configure do
+  exclude_keys "created_at", "updated_at"
+end
+```
+
+Now, the `id` key will be included in rspec-oj's comparisons. Keys can also be excluded/included
+per matcher by chaining the `excluding` or `including` methods (as shown above) which will add or
+subtract from the globally excluded keys, respectively.
+
+### Paths
+
+Each of rspec-oj's matchers deal with JSON "paths." These are simple strings of "/" separated
+hash keys and array indexes. For instance, with the following JSON:
+
+    {
+      "first_name": "Steve",
+      "last_name": "Richert",
+      "friends": [
+        {
+          "first_name": "Catie",
+          "last_name": "Richert"
+        }
+      ]
+    }
+
+We could access the first friend's first name with the path `"friends/0/first_name"`.
+
+## Cucumber
+
+rspec-oj provides Cucumber steps that utilize its RSpec matchers and that's where rspec-oj really
+shines. This is perfect for testing your app's JSON API.
+
+In order to use the Cucumber steps, in your `env.rb` you must:
+
+```ruby
+require "rspec/oj/cucumber"
+```
+
+You also need to define a `last_json` method. If you're using Capybara, it could be as simple as:
+
+```ruby
+def last_json
+  page.source
+end
+```
+
+Now, you can use the rspec-oj steps in your features:
+
+```cucumber
+Feature: User API
+  Background:
+    Given the following users exist:
+      | id | first_name | last_name |
+      | 1  | Steve      | Richert   |
+      | 2  | Catie      | Richert   |
+    And "Steve Richert" is friends with "Catie Richert"
+
+  Scenario: Index action
+    When I visit "/users.json"
+    Then the JSON response should have 2 users
+    And the JSON response at "0/id" should be 1
+    And the JSON response at "1/id" should be 2
+
+  Scenario: Show action
+    When I visit "/users/1.json"
+    Then the JSON response at "first_name" should be "Steve"
+    And the JSON response at "last_name" should be "Richert"
+    And the JSON response should have "created_at"
+    And the JSON response at "created_at" should be a string
+    And the JSON response at "friends" should be:
+      """
+      [
+        {
+          "id": 2,
+          "first_name": "Catie",
+          "last_name": "Richert"
+        }
+      ]
+      """
+```
+
+The background steps above aren't provided by rspec-oj and the "visit" steps are provided by
+Capybara. The remaining steps, rspec-oj provides. They're versatile and can be used in plenty of
+different formats:
+
+```cucumber
+Then the JSON should be:
+  """
+  {
+    "key": "value"
+  }
+  """
+Then the JSON at "path" should be:
+  """
+  [
+    "entry",
+    "entry"
+  ]
+  """
+
+Then the JSON should be {"key":"value"}
+Then the JSON at "path" should be {"key":"value"}
+Then the JSON should be ["entry","entry"]
+Then the JSON at "path" should be ["entry","entry"]
+Then the JSON at "path" should be "string"
+Then the JSON at "path" should be 10
+Then the JSON at "path" should be 10.0
+Then the JSON at "path" should be 1e+1
+Then the JSON at "path" should be true
+Then the JSON at "path" should be false
+Then the JSON at "path" should be null
+
+Then the JSON should include:
+  """
+  {
+    "key": "value"
+  }
+  """
+Then the JSON at "path" should include:
+  """
+  [
+    "entry",
+    "entry"
+  ]
+  """
+
+Then the JSON should include {"key":"value"}
+Then the JSON at "path" should include {"key":"value"}
+Then the JSON should include ["entry","entry"]
+Then the JSON at "path" should include ["entry","entry"]
+Then the JSON should include "string"
+Then the JSON at "path" should include "string"
+Then the JSON should include 10
+Then the JSON at "path" should include 10
+Then the JSON should include 10.0
+Then the JSON at "path" should include 10.0
+Then the JSON should include 1e+1
+Then the JSON at "path" should include 1e+1
+Then the JSON should include true
+Then the JSON at "path" should include true
+Then the JSON should include false
+Then the JSON at "path" should include false
+Then the JSON should include null
+Then the JSON at "path" should include null
+
+Then the JSON should have "path"
+
+Then the JSON should be a hash
+Then the JSON at "path" should be an array
+Then the JSON at "path" should be a float
+
+Then the JSON should have 1 entry
+Then the JSON at "path" should have 2 entries
+Then the JSON should have 3 keys
+Then the JSON should have 4 whatevers
+```
+
+_All instances of "should" above could be followed by "not" and all instances of "JSON" could be downcased and/or followed by "response."_
+
+### Table Format
+
+Another step exists that uses Cucumber's table formatting and wraps two of the above steps:
+
+```cucumber
+Then the JSON should have the following:
+  | path/0 | {"key":"value"}   |
+  | path/1 | ["entry","entry"] |
+```
+
+Any number of rows can be given. The step above is equivalent to:
+
+```cucumber
+Then the JSON at "path/0" should be {"key":"value"}
+And the JSON at "path/1" should be ["entry","entry"]
+```
+
+If only one column is given:
+
+```cucumber
+Then the JSON should have the following:
+  | path/0 |
+  | path/1 |
+```
+
+This is equivalent to:
+
+```cucumber
+Then the JSON should have "path/0"
+And the JSON should have "path/1"
+```
+
+### JSON Memory
+
+There's one more Cucumber step that rspec-oj provides which hasn't been used above. It's used to
+memorize JSON for reuse in later steps. You can "keep" all or a portion of the JSON by giving a
+name by which to remember it.
+
+```cucumber
+Feature: User API
+  Scenario: Index action includes full user JSON
+    Given the following user exists:
+      | id | first_name | last_name |
+      | 1  | Steve      | Richert   |
+    And I visit "/users/1.json"
+    And I keep the JSON response as "USER_1"
+    When I visit "/users.json"
+    Then the JSON response should be:
+      """
+      [
+        %{USER_1}
+      ]
+      """
+```
+
+You can memorize JSON at a path:
+
+```cucumber
+Given I keep the JSON response at "first_name" as "FIRST_NAME"
+```
+
+You can remember JSON at a path:
+
+```cucumber
+Then the JSON response at "0/first_name" should be:
+  """
+  %{FIRST_NAME}
+  """
+```
+
+You can also remember JSON inline:
+
+```cucumber
+Then the JSON response at "0/first_name" should be %{FIRST_NAME}
+```
+
+### More
+
+Check out the [specs](https://github.com/mhenrixon/rspec-oj/blob/master/spec)
+and [features](https://github.com/mhenrixon/rspec-oj/blob/master/features) to see all the
+various ways you can use rspec-oj.
+
+## Contributing
+
+If you come across any issues, please [tell us](https://github.com/mhenrixon/rspec-oj/issues).
+Pull requests (with tests) are appreciated. No pull request is too small. Please help with:
+
+* Reporting bugs
+* Suggesting features
+* Writing or improving documentation
+* Fixing typos
+* Cleaning whitespace
+* Refactoring code
+* Adding tests
+* Closing [issues](https://github.com/mhenrixon/rspec-oj/issues)
+
+If you report a bug and don't include a fix, please include a failing test.
+
+## Copyright
+
+Copyright © 2020 Steve Richert
+
+See [LICENSE](https://github.com/mhenrixon/rspec-oj/blob/master/LICENSE) for details.

data/lib/rspec/oj/configuration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RSpec
+  module Oj
+    module Configuration
+      DEFAULT_EXCLUDED_KEYS = %w[id created_at updated_at].freeze
+
+      attr_accessor :directory
+
+      def configure(&block)
+        instance_eval(&block)
+      end
+
+      def excluded_keys
+        @excluded_keys ||= DEFAULT_EXCLUDED_KEYS
+      end
+
+      def excluded_keys=(keys)
+        @excluded_keys = keys.map(&:to_s).uniq
+      end
+
+      def exclude_keys(*keys)
+        self.excluded_keys = keys
+      end
+
+      def reset
+        instance_variables.each { |ivar| remove_instance_variable(ivar) }
+      end
+    end
+  end
+end

data/lib/rspec/oj/cucumber.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'rspec-oj'
+
+World(RSpec::Oj::Helpers, RSpec::Oj::Matchers)
+
+After do
+  RSpec::Oj.forget
+end
+
+When(/^(?:I )?keep the (?:JSON|json)(?: response)?(?: at "(.*)")? as "(.*)"$/) do |path, key|
+  RSpec::Oj.memorize(key, normalize_json(last_json, path))
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? be:$/) do |path, negative, json|
+  if negative
+    expect(last_json).not_to be_json_eql(RSpec::Oj.remember(json)).at_path(path)
+  else
+    expect(last_json).to be_json_eql(RSpec::Oj.remember(json)).at_path(path)
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? be file "(.+)"$/) do |path, negative, file_path|
+  if negative
+    expect(last_json).not_to be_json_eql.to_file(file_path).at_path(path)
+  else
+    expect(last_json).to be_json_eql.to_file(file_path).at_path(path)
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? be (".*"|\-?\d+(?:\.\d+)?(?:[eE][\+\-]?\d+)?|\[.*\]|%?\{.*\}|true|false|null)$/) do |path, negative, value| # rubocop:disable Layout/LineLength
+  if negative
+    expect(last_json).not_to be_json_eql(RSpec::Oj.remember(value)).at_path(path)
+  else
+    expect(last_json).to be_json_eql(RSpec::Oj.remember(value)).at_path(path)
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? include:$/) do |path, negative, json|
+  if negative
+    expect(last_json).not_to include_json(RSpec::Oj.remember(json)).at_path(path)
+  else
+    expect(last_json).to include_json(RSpec::Oj.remember(json)).at_path(path)
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? include file "(.+)"$/) do |path, negative, file_path|
+  if negative
+    expect(last_json).not_to include_json.from_file(file_path).at_path(path)
+  else
+    expect(last_json).to include_json.from_file(file_path).at_path(path)
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? include (".*"|\-?\d+(?:\.\d+)?(?:[eE][\+\-]?\d+)?|\[.*\]|%?\{.*\}|true|false|null)$/) do |path, negative, value| # rubocop:disable Layout/LineLength
+  if negative
+    expect(last_json).not_to include_json(RSpec::Oj.remember(value)).at_path(path)
+  else
+    expect(last_json).to include_json(RSpec::Oj.remember(value)).at_path(path)
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should have the following:$/) do |base, table|
+  table.raw.each do |path, value|
+    path = [base, path].compact.join('/')
+
+    if value
+      step %(the JSON at "#{path}" should be:), value
+    else
+      step %(the JSON should have "#{path}")
+    end
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)? should( not)? have "(.*)"$/) do |negative, path|
+  if negative
+    expect(last_json).not_to have_json_path(path)
+  else
+    expect(last_json).to have_json_path(path)
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? be an? (.*)$/) do |path, negative, type|
+  if negative
+    expect(last_json).not_to have_json_type(type).at_path(path)
+  else
+    expect(last_json).to have_json_type(type).at_path(path)
+  end
+end
+
+Then(/^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? have (\d+)/) do |path, negative, size|
+  if negative
+    expect(last_json).not_to have_json_size(size.to_i).at_path(path)
+  else
+    expect(last_json).to have_json_size(size.to_i).at_path(path)
+  end
+end

data/lib/rspec/oj/errors.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    class Error < StandardError
+    end
+
+    class MissingPath < Error
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def to_s
+        %(Missing JSON path "#{path}")
+      end
+    end
+
+    class MissingDirectory < Error
+      def to_s
+        'No JsonSpec.directory set'
+      end
+    end
+
+    class MissingFile < Error
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def to_s
+        "No JSON file at #{path}"
+      end
+    end
+
+    class EnumerableExpected < Error
+      attr_reader :actual_value
+
+      def initialize(actual_value)
+        @actual_value = actual_value
+      end
+
+      def to_s
+        "Enumerable expected, got #{actual_value.inspect}"
+      end
+    end
+  end
+end

data/lib/rspec/oj/exclusion.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    module Exclusion
+      module_function
+
+      def exclude_keys(ruby)
+        case ruby
+        when Hash
+          ruby.sort.each_with_object({}) do |(key, value), hash|
+            hash[key] = exclude_keys(value) unless exclude_key?(key)
+          end
+        when Array
+          ruby.map { |v| exclude_keys(v) }
+        else ruby
+        end
+      end
+
+      def exclude_key?(key)
+        excluded_keys.include?(key)
+      end
+
+      def excluded_keys
+        @excluded_keys ||= Set.new(RSpec::Oj.excluded_keys)
+      end
+    end
+  end
+end

data/lib/rspec/oj/helpers.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'oj'
+
+module RSpec
+  module Oj
+    module Helpers
+      extend self
+
+      def parse_json(json, path = nil)
+        return parse_json(generate_normalized_json(json), path) unless json.is_a?(String)
+
+        ruby = ::Oj.load("[#{json}]", mode: :compat).first
+        value_at_json_path(ruby, path)
+      rescue EncodingError
+        begin
+          ::Oj.load(json)
+        rescue ::Oj::ParseError
+          json
+        end
+      end
+
+      def normalize_json(json, path = nil)
+        ruby = parse_json(json, path)
+        generate_normalized_json(ruby)
+      end
+
+      def generate_normalized_json(ruby)
+        case ruby
+        when Hash, Array
+          ::Oj.dump(ruby, mode: :compat)
+        else
+          ::Oj.to_json(ruby, mode: :compat)
+        end
+      end
+
+      def load_json(relative_path)
+        missing_json_directory! unless RSpec::Oj.directory
+        path = File.join(RSpec::Oj.directory, relative_path)
+        missing_json_file!(path) unless File.exist?(path)
+        File.read(path)
+      end
+
+      private
+
+      def value_at_json_path(ruby, path)
+        return ruby unless path
+
+        path.split('/').reduce(ruby) do |memo, key|
+          case memo
+          when Hash
+            memo.fetch(key) { missing_json_path!(path) }
+          when Array
+            missing_json_path!(path) unless /^\d+$/.match?(key)
+            memo.fetch(key.to_i) { missing_json_path!(path) }
+          else
+            missing_json_path!(path)
+          end
+        end
+      end
+
+      def missing_json_path!(path)
+        raise RSpec::Oj::MissingPath, path
+      end
+
+      def missing_json_directory!
+        raise RSpec::Oj::MissingDirectory
+      end
+
+      def missing_json_file!(path)
+        raise RSpec::Oj::MissingFile, path
+      end
+    end
+  end
+end

data/lib/rspec/oj/matchers/be_json_eql.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    module Matchers
+      class BeJsonEql
+        include RSpec::Oj::Helpers
+        include RSpec::Oj::Exclusion
+        include RSpec::Oj::Messages
+
+        attr_reader :expected, :actual
+
+        def diffable?
+          true
+        end
+
+        def initialize(expected_json = nil)
+          @expected_json = expected_json
+          @path = nil
+        end
+
+        def matches?(actual_json)
+          raise 'Expected equivalent JSON not provided' if @expected_json.nil?
+
+          @actual = scrub(actual_json, @path)
+          @expected = scrub(@expected_json)
+          @actual == @expected
+        end
+
+        def at_path(path)
+          @path = path
+          self
+        end
+
+        def to_file(path)
+          @expected_json = load_json(path)
+          self
+        end
+
+        def excluding(*keys)
+          excluded_keys.merge(keys.map(&:to_s))
+          self
+        end
+
+        def including(*keys)
+          excluded_keys.subtract(keys.map(&:to_s))
+          self
+        end
+
+        def failure_message
+          message_with_path('Expected equivalent JSON')
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          message_with_path('Expected inequivalent JSON')
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def description
+          message_with_path('equal JSON')
+        end
+
+        private
+
+        def scrub(json, path = nil)
+          generate_normalized_json(exclude_keys(parse_json(json, path))).chomp + "\n"
+        end
+      end
+    end
+  end
+end

data/lib/rspec/oj/matchers/have_json_path.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    module Matchers
+      class HaveJsonPath
+        include RSpec::Oj::Helpers
+
+        def initialize(path)
+          @path = path
+        end
+
+        def matches?(json)
+          parse_json(json, @path)
+          true
+        rescue RSpec::Oj::MissingPath
+          false
+        end
+
+        def failure_message
+          %(Expected JSON path "#{@path}")
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          %(Expected no JSON path "#{@path}")
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def description
+          %(have JSON path "#{@path}")
+        end
+      end
+    end
+  end
+end

data/lib/rspec/oj/matchers/have_json_size.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    module Matchers
+      class HaveJsonSize
+        include RSpec::Oj::Helpers
+        include RSpec::Oj::Messages
+
+        def initialize(size)
+          @expected = size
+          @path = nil
+        end
+
+        def matches?(json)
+          ruby = parse_json(json, @path)
+          raise EnumerableExpected, ruby unless Enumerable === ruby
+
+          @actual = ruby.size
+          @actual == @expected
+        end
+
+        def at_path(path)
+          @path = path
+          self
+        end
+
+        def failure_message
+          message_with_path("Expected JSON value size to be #{@expected}, got #{@actual}")
+        end
+
+        def failure_message_when_negated
+          message_with_path("Expected JSON value size to not be #{@expected}, got #{@actual}")
+        end
+
+        def description
+          message_with_path(%(have JSON size "#{@expected}"))
+        end
+      end
+    end
+  end
+end

data/lib/rspec/oj/matchers/have_json_type.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    module Matchers
+      class HaveJsonType
+        include RSpec::Oj::Helpers
+        include RSpec::Oj::Messages
+
+        def initialize(type)
+          @classes = type_to_classes(type)
+          @path = nil
+        end
+
+        def matches?(json)
+          @ruby = parse_json(json, @path)
+          @classes.any? { |c| c === @ruby }
+        end
+
+        def at_path(path)
+          @path = path
+          self
+        end
+
+        def failure_message
+          message_with_path("Expected JSON value type to be #{@classes.join(', ')}, got #{@ruby.class}")
+        end
+
+        def failure_message_when_negated
+          message_with_path("Expected JSON value type to not be #{@classes.join(', ')}, got #{@ruby.class}")
+        end
+
+        def description
+          message_with_path(%(have JSON type "#{@classes.join(', ')}"))
+        end
+
+        private
+
+        def type_to_classes(type)
+          case type
+          when Class then [type]
+          when Array then type.map { |t| type_to_classes(t) }.flatten
+          else
+            case type.to_s.downcase
+            when 'boolean'     then [TrueClass, FalseClass]
+            when 'object'      then [Hash]
+            when 'nil', 'null' then [NilClass]
+            else [Module.const_get(type.to_s.capitalize)]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/oj/matchers/include_json.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    module Matchers
+      class IncludeJson
+        include RSpec::Oj::Helpers
+        include RSpec::Oj::Exclusion
+        include RSpec::Oj::Messages
+
+        def initialize(expected_json = nil)
+          @expected_json = expected_json
+          @path = nil
+        end
+
+        def matches?(actual_json)
+          raise 'Expected included JSON not provided' if @expected_json.nil?
+
+          @actual_json = actual_json
+
+          actual = parse_json(actual_json, @path)
+          expected = exclude_keys(parse_json(@expected_json))
+          case actual
+          when Hash then actual.values.map { |v| exclude_keys(v) }.include?(expected)
+          when Array then actual.map { |e| exclude_keys(e) }.include?(expected)
+          when String then actual.include?(expected)
+          else false
+          end
+        end
+
+        def at_path(path)
+          @path = path
+          self
+        end
+
+        def from_file(path)
+          @expected_json = load_json(path)
+          self
+        end
+
+        def excluding(*keys)
+          excluded_keys.merge(keys.map(&:to_s))
+          self
+        end
+
+        def including(*keys)
+          excluded_keys.subtract(keys.map(&:to_s))
+          self
+        end
+
+        def failure_message
+          message_with_path("Expected #{@actual_json} to include #{@expected_json}")
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          message_with_path("Expected #{@actual_json} to not include #{@expected_json}")
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def description
+          message_with_path('include JSON')
+        end
+      end
+    end
+  end
+end

data/lib/rspec/oj/matchers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rspec/oj/matchers/be_json_eql'
+require 'rspec/oj/matchers/include_json'
+require 'rspec/oj/matchers/have_json_path'
+require 'rspec/oj/matchers/have_json_type'
+require 'rspec/oj/matchers/have_json_size'
+
+module RSpec
+  module Oj
+    module Matchers
+      def be_json_eql(json = nil)
+        RSpec::Oj::Matchers::BeJsonEql.new(json)
+      end
+
+      def include_json(json = nil)
+        RSpec::Oj::Matchers::IncludeJson.new(json)
+      end
+
+      def have_json_path(path) # rubocop:disable Naming/PredicateName
+        RSpec::Oj::Matchers::HaveJsonPath.new(path)
+      end
+
+      def have_json_type(type) # rubocop:disable Naming/PredicateName
+        RSpec::Oj::Matchers::HaveJsonType.new(type)
+      end
+
+      def have_json_size(size) # rubocop:disable Naming/PredicateName
+        RSpec::Oj::Matchers::HaveJsonSize.new(size)
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpec::Oj::Matchers
+end

data/lib/rspec/oj/memory.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    module Memory
+      def memory
+        @memory ||= {}
+      end
+
+      def memorize(key, value)
+        memory[key.to_sym] = value
+      end
+
+      def remember(json)
+        memory.empty? ? json : json % memory
+      end
+
+      def forget
+        memory.clear
+      end
+    end
+  end
+end

data/lib/rspec/oj/messages.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    module Messages
+      def message_with_path(message)
+        message = +message << %( at path "#{@path}") if @path
+        message
+      end
+    end
+  end
+end

data/lib/rspec/oj/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Oj
+    VERSION = '1.0.0'
+  end
+end

data/lib/rspec-oj.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'oj'
+require 'rspec'
+require 'rspec/oj/errors'
+require 'rspec/oj/configuration'
+require 'rspec/oj/exclusion'
+require 'rspec/oj/helpers'
+require 'rspec/oj/messages'
+require 'rspec/oj/matchers'
+require 'rspec/oj/memory'
+
+module RSpec
+  module Oj
+    extend Configuration
+    extend Memory
+  end
+end

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification
+name: rspec-oj
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mikael Henriksson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-mhenrixon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.80.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.80.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: simplecov-oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.18.0
+description: RSpec matchers and Cucumber steps for testing JSON content
+email:
+- mikael@mhenrixon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/rspec-oj.rb
+- lib/rspec/oj/configuration.rb
+- lib/rspec/oj/cucumber.rb
+- lib/rspec/oj/errors.rb
+- lib/rspec/oj/exclusion.rb
+- lib/rspec/oj/helpers.rb
+- lib/rspec/oj/matchers.rb
+- lib/rspec/oj/matchers/be_json_eql.rb
+- lib/rspec/oj/matchers/have_json_path.rb
+- lib/rspec/oj/matchers/have_json_size.rb
+- lib/rspec/oj/matchers/have_json_type.rb
+- lib/rspec/oj/matchers/include_json.rb
+- lib/rspec/oj/memory.rb
+- lib/rspec/oj/messages.rb
+- lib/rspec/oj/version.rb
+homepage: https://github.com/mhenrixon/rspec-oj
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib/rspec
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Easily handle JSON in RSpec and Cucumber
+test_files: []