rspec-json_expectations 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d3da7374ac61ca45bda7f28a31cd3343e11576e
+  data.tar.gz: 0ff730addd56dc7fc87021b5c358c8b399645c8b
+SHA512:
+  metadata.gz: 9a7aad7424c140606260fbc15bb5e67e61e99e724c2cc0eeb87b8fe6d9f52abf332b4b3ffd7f6d17862d92fd059ed2406583b2e7ab7e9b6faa79aeb002f4c7c7
+  data.tar.gz: 22c5a1adf525eec9cf4d6e77aeaede263a34db007b47d4212cabb9607e8f06a56caf723cd7631659b88d1dce2a16a1297918702aaa26b72c4468efa91f6d9dea

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+gemfiles/*.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/dummy

data/.travis.yml

@@ -0,0 +1,9 @@
+script: bundle exec cucumber
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.2
+gemfile:
+  - gemfiles/rspec-2
+  - gemfiles/rspec-3

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alexey Fedorov
+
+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,103 @@
+# RSpec::JsonExpectations
+
+[![Build Status](https://travis-ci.org/waterlink/rspec-json_expectations.svg?branch=master)](https://travis-ci.org/waterlink/rspec-json_expectations)
+
+Set of matchers and helpers to allow you test your APIs responses like a pro.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rspec-json_expectations'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rspec-json_expectations
+
+## Setup
+
+Simply add this line at the top of your spec helper:
+
+```ruby
+require "rspec/json_expectations"
+```
+
+## Usage
+
+Simple example:
+
+```ruby
+require "spec_helper"
+
+RSpec.describe "User API" do
+  subject { api_get :user }
+
+  it "has basic info about user" do
+    expect(subject).to include_json(
+      id: 25,
+      email: "john.smith@example.com",
+      name: "John"
+    )
+  end
+  
+  it "has some additional info about user" do
+    expect(subject).to include_json(
+      premium: "gold",
+      gamification_score: 79
+    )
+  end
+end
+```
+
+And the output when I run it is:
+
+```
+FF
+
+Failures:
+
+  1) User API has basic info about user
+     Failure/Error: expect(subject).to include_json(
+       
+                 json atom at path "id" is not equal to expected value:
+       
+                   expected: 25
+                        got: 37
+                 
+                 json atom at path "name" is not equal to expected value:
+       
+                   expected: "John"
+                        got: "Smith J."
+                 
+     # ./spec/user_api_spec.rb:18:in `block (2 levels) in <top (required)>'
+
+  2) User API has some additional info about user
+     Failure/Error: expect(subject).to include_json(
+       
+                 json atom at path "premium" is not equal to expected value:
+       
+                   expected: "gold"
+                        got: "silver"
+                 
+     # ./spec/user_api_spec.rb:26:in `block (2 levels) in <top (required)>'
+
+Finished in 0.00102 seconds (files took 0.0853 seconds to load)
+2 examples, 2 failures
+
+Failed examples:
+
+rspec ./spec/user_api_spec.rb:17 # User API has basic info about user
+rspec ./spec/user_api_spec.rb:25 # User API has some additional info about user
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/waterlink/rspec-json_expectations/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/build

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+bin/with-rspec-2 install && bin/with-rspec-3 install && bin/with-rspec-2 exec cucumber && bin/with-rspec-3 exec cucumber && echo "SUCCESS" || echo "FAILED"

data/bin/with-rspec-2

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+BUNDLE_GEMFILE=gemfiles/rspec-2 bundle $*

data/bin/with-rspec-3

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+BUNDLE_GEMFILE=gemfiles/rspec-3 bundle $*

data/features/rspec/json_expectations/array_support.feature

@@ -0,0 +1,210 @@
+Feature: Array matching support for include_json matcher
+
+  As a developer extensively testing my APIs
+  I want to be able to match json parts with array
+
+  Background:
+    Given a file "spec/spec_helper.rb" with:
+          """ruby
+          require "rspec/json_expectations"
+          """
+      And a local "JSON_WITH_ARRAY" with:
+          """json
+          {
+            "per_page": 3,
+            "count": 17,
+            "page": 2,
+            "page_count": 6,
+            "results": [
+              {
+                "id": 25,
+                "email": "john.smith@example.com",
+                "badges": ["first flight", "day & night"],
+                "name": "John"
+              },
+              {
+                "id": 26,
+                "email": "john.smith@example.com",
+                "badges": ["first flight"],
+                "name": "John"
+              },
+              {
+                "id": 27,
+                "email": "john.smith@example.com",
+                "badges": ["day & night"],
+                "name": "John"
+              }
+            ]
+          }
+          """
+      And a local "JSON_WITH_ROOT_ARRAY" with:
+          """json
+          [
+            "first flight",
+            "day & night"
+          ]
+          """
+
+  Scenario: Expecting json string to fully include json with arrays
+    Given a file "spec/nested_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{JSON_WITH_ARRAY}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                results: [
+                  { id: 25, badges: ["first flight", "day & night"] },
+                  { id: 26, badges: ["first flight"] },
+                  { id: 27, badges: ["day & night"] }
+                ]
+              )
+            end
+          end
+          """
+     When I run "rspec spec/nested_example_spec.rb"
+     Then I see:
+          """
+          1 example, 0 failures
+          """
+
+  Scenario: Expecting wrong json string to fully include json with arrays
+    Given a file "spec/nested_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{JSON_WITH_ARRAY}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                results: [
+                  { id: 24, badges: [] },
+                  { id: 25, badges: ["first flight", "day & night"] },
+                  { id: 26, badges: ["first flight"] },
+                  { id: 27, badges: ["day & night"] }
+                ]
+              )
+            end
+          end
+          """
+     When I run "rspec spec/nested_example_spec.rb"
+     Then I see:
+          """
+                           json atom at path "results/0/id" is not equal to expected value:
+          """
+      And I see:
+          """
+                           json atom at path "results/1/id" is not equal to expected value:
+          """
+      And I see:
+          """
+                           json atom at path "results/1/badges/1" is missing
+          """
+      And I see:
+          """
+                           json atom at path "results/2/id" is not equal to expected value:
+          """
+      And I see:
+          """
+                           json atom at path "results/2/badges/0" is not equal to expected value:
+          """
+      And I see:
+          """
+                             expected: "first flight"
+                                  got: "day & night"
+          """
+      And I see:
+          """
+                           json atom at path "results/3" is missing
+          """
+
+  Scenario: Expecting json string to partially include json with arrays
+    Given a file "spec/nested_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{JSON_WITH_ARRAY}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                results: {
+                  2 => { id: 27, badges: ["day & night"] }
+                }
+              )
+            end
+          end
+          """
+     When I run "rspec spec/nested_example_spec.rb"
+     Then I see:
+          """
+          1 example, 0 failures
+          """
+
+  Scenario: Expecting wrong json string to partially include json with arrays
+    Given a file "spec/nested_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{JSON_WITH_ARRAY}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                results: {
+                  2 => { id: 28, badges: ["day & night"] }
+                }
+              )
+            end
+          end
+          """
+     When I run "rspec spec/nested_example_spec.rb"
+     Then I see:
+          """
+                           json atom at path "results/2/id" is not equal to expected value:
+          """
+
+  Scenario: Expecting json string with array at root to fully include json with arrays
+    Given a file "spec/nested_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{JSON_WITH_ROOT_ARRAY}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                [ "first flight", "day & night" ]
+              )
+            end
+          end
+          """
+     When I run "rspec spec/nested_example_spec.rb"
+     Then I see:
+          """
+          1 example, 0 failures
+          """
+
+  Scenario: Expecting wrong json string with array at root to fully include json with arrays
+    Given a file "spec/nested_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{JSON_WITH_ROOT_ARRAY}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                [ "first flight", "day & night", "super hero" ]
+              )
+            end
+          end
+          """
+     When I run "rspec spec/nested_example_spec.rb"
+     Then I see:
+          """
+                           json atom at path "2" is missing
+          """

data/features/rspec/json_expectations/include_json_matcher.feature

@@ -0,0 +1,116 @@
+Feature: include_json matcher
+
+  As a developer extensively testing my APIs with RSpec
+  I want to have a suitable tool to test my API responses
+  And I want to use simple ruby hashes to describe the parts of response
+  For that I need a custom matcher
+
+  Background:
+    Given a file "spec/spec_helper.rb" with:
+          """ruby
+          require "rspec/json_expectations"
+          """
+      And a local "SIMPLE_JSON" with:
+          """json
+          {
+            "id": 25,
+            "email": "john.smith@example.com",
+            "name": "John"
+          }
+          """
+      And a local "BIG_JSON" with:
+          """json
+          {
+            "id": 25,
+            "email": "john.smith@example.com",
+            "password_hash": "super_md5_hash_that_is_unbreakable",
+            "name": "John",
+            "profile_id": 39,
+            "role": "admin"
+          }
+          """
+
+  Scenario: Expecting json string to include simple json
+    Given a file "spec/simple_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{SIMPLE_JSON}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                id: 25,
+                email: "john.smith@example.com",
+                name: "John"
+              )
+            end
+          end
+          """
+     When I run "rspec spec/simple_example_spec.rb"
+     Then I see:
+          """
+          1 example, 0 failures
+          """
+
+  Scenario: Expecting wrong json string to include simple json
+    Given a file "spec/simple_with_fail_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{SIMPLE_JSON}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                id: 37,
+                email: "john.smith@example.com",
+                name: "Smith"
+              )
+            end
+          end
+          """
+     When I run "rspec spec/simple_with_fail_spec.rb"
+     Then I see:
+          """
+          1 example, 1 failure
+          """
+      And I see:
+          """
+                             expected: 37
+                                  got: 25
+          """
+      And I see:
+          """
+                             expected: "Smith"
+                                  got: "John"
+          """
+      And I see:
+          """ruby
+          # ./spec/simple_with_fail_spec.rb
+          """
+
+  Scenario: Expecting json response with excessive fields to include 'smaller' json
+    Given a file "spec/excessive_fields_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{BIG_JSON}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                id: 25,
+                name: "John",
+                profile_id: 39,
+                role: "admin"
+              )
+            end
+          end
+          """
+     When I run "rspec spec/excessive_fields_spec.rb"
+     Then I see:
+          """
+          1 example, 0 failures
+          """
+

data/features/rspec/json_expectations/negation_matching.feature

@@ -0,0 +1,78 @@
+Feature: negation matching for include_json matcher
+
+  As a developer extensively testing my APIs
+  I want to be able to check if JSON response does not include some json part
+  For that I need appropriate negation matching mechanism
+  Where all json paths specified by include_json matcher should fail for
+  expectation to succeed
+
+  Background:
+    Given a file "spec/spec_helper.rb" with:
+          """ruby
+          require "rspec/json_expectations"
+          """
+      And a local "SIMPLE_JSON" with:
+          """json
+          {
+            "id": 25,
+            "email": "john.smith@example.com",
+            "name": "John"
+          }
+          """
+
+  Scenario: Expecting json string not to incldue simple json
+    Given a file "spec/simple_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{SIMPLE_JSON}' }
+
+            it "has basic info about user" do
+              expect(subject).not_to include_json(
+                id: 26,
+                email: "sarah@example.org",
+                name: "Sarah C.",
+                missing: "field"
+              )
+            end
+          end
+          """
+     When I run "rspec spec/simple_example_spec.rb"
+     Then I see:
+          """
+          1 example, 0 failures
+          """
+
+  Scenario: Expecting json string not to incldue simple json, when it is partially included
+    Given a file "spec/simple_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{SIMPLE_JSON}' }
+
+            it "has basic info about user" do
+              expect(subject).not_to include_json(
+                id: 26,
+                email: /john.*@example.com/,
+                name: "John",
+                missing: "field"
+              )
+            end
+          end
+          """
+     When I run "rspec spec/simple_example_spec.rb"
+     Then I see:
+          """
+          1 example, 1 failure
+          """
+      And I see:
+          """
+                           json atom at path "email" should not match expected regex:
+          """
+      And I see:
+          """
+                           json atom at path "name" should not equal to expected value:
+          """
+

data/features/rspec/json_expectations/nested_json_support.feature

@@ -0,0 +1,63 @@
+Feature: nested json support with include_json matcher
+
+  As a developer extensively testing my APIs
+  I want to be able to easily test nested JSON responses
+
+  Background:
+    Given a file "spec/spec_helper.rb" with:
+          """ruby
+          require "rspec/json_expectations"
+          """
+      And a local "NESTED_JSON" with:
+          """json
+          {
+            "id": 25,
+            "email": "john.smith@example.com",
+            "gamification": {
+              "rating": 93,
+              "score": 397
+            },
+            "name": "John"
+          }
+          """
+
+  Scenario: Expecting json string to include nested json
+    Given a file "spec/nested_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{NESTED_JSON}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                id: 25,
+                email: "john.smith@example.com",
+                name: "John"
+              )
+            end
+
+            it "has gamification info for user" do
+              expect(subject).to include_json(
+                gamification: {
+                  rating: 93,
+                  score: 355
+                }
+              )
+            end
+          end
+          """
+     When I run "rspec spec/nested_example_spec.rb"
+     Then I see:
+          """
+          2 examples, 1 failure
+          """
+      And I see:
+          """
+                           json atom at path "gamification/score" is not equal to expected value:
+          """
+      And I see:
+          """
+                             expected: 355
+                                  got: 397
+          """

data/features/rspec/json_expectations/regular_expressions_support.feature

@@ -0,0 +1,94 @@
+Feature: regular expressions support with include_json matcher
+
+  As a developer extensively testing my APIs
+  I want to be able to match string values by regex
+
+  Background:
+    Given a file "spec/spec_helper.rb" with:
+          """ruby
+          require "rspec/json_expectations"
+          """
+      And a local "SIMPLE_JSON" with:
+          """json
+          {
+            "id": 25,
+            "email": "john.smith@example.com",
+            "name": "John",
+            "code": "5wmsx6ae7p",
+            "url": "https://test.example.org/api/v5/users/5wmsx6ae7p.json"
+          }
+          """
+      And a local "WRONG_JSON" with:
+          """json
+          {
+            "id": 25,
+            "email": "john.smith@example.com",
+            "name": "John",
+            "code": "5wmsx6ae7psome-trash",
+            "url": "https://test.example.org/api/v6/users/5wmsx6ae7p.json"
+          }
+          """
+
+  Scenario: Expecting json string to include simple json with regex
+    Given a file "spec/simple_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{SIMPLE_JSON}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                id: 25,
+                email: "john.smith@example.com",
+                name: "John",
+                code: /^[a-z0-9]{10}$/,
+                url: %%r{api/v5/users/[a-z0-9]{10}.json}
+              )
+            end
+          end
+          """
+     When I run "rspec spec/simple_example_spec.rb"
+     Then I see:
+          """
+          1 example, 0 failures
+          """
+
+  Scenario: Expecting wrong json string to include simple json with regex
+    Given a file "spec/simple_example_spec.rb" with:
+          """ruby
+          require "spec_helper"
+
+          RSpec.describe "A json response" do
+            subject { '%{WRONG_JSON}' }
+
+            it "has basic info about user" do
+              expect(subject).to include_json(
+                id: 25,
+                email: "john.smith@example.com",
+                name: "John",
+                code: /^[a-z0-9]{10}$/,
+                url: %%r{api/v5/users/[a-z0-9]{10}.json}
+              )
+            end
+          end
+          """
+     When I run "rspec spec/simple_example_spec.rb"
+     Then I see:
+          """
+                           json atom at path "code" does not match expected regex:
+          """
+      And I see:
+          """
+                             expected: /^[a-z0-9]{10}$/
+                                  got: "5wmsx6ae7psome-trash"
+          """
+      And I see:
+          """
+                           json atom at path "url" does not match expected regex:
+          """
+      And I see:
+          """
+                             expected: /api\/v5\/users\/[a-z0-9]{10}.json/
+                                  got: "https://test.example.org/api/v6/users/5wmsx6ae7p.json"
+          """

data/features/step_definitions/steps.rb

@@ -0,0 +1,32 @@
+DUMMY_FOLDER = "dummy"
+
+def init
+  `mkdir -p #{DUMMY_FOLDER}`
+  `cp -r gemfiles #{DUMMY_FOLDER}`
+  `cp *.gemspec #{DUMMY_FOLDER}`
+  `cp -r lib #{DUMMY_FOLDER}`
+end
+
+init
+
+Given(/^a file "(.*?)" with:$/) do |filename, contents|
+  @locals ||= {}
+  full_path = File.join(DUMMY_FOLDER, filename)
+  `mkdir -p #{File.dirname(full_path)}`
+  File.open(full_path, 'w') { |f| f.write(contents % @locals) }
+end
+
+Given(/^a local "(.*?)" with:$/) do |key, value|
+  @locals ||= {}
+  @locals[key.to_sym] = value
+end
+
+When(/^I run "(.*?)"$/) do |command|
+  @output = `cd #{DUMMY_FOLDER}; #{command}`
+  puts @output
+end
+
+Then(/^I see:$/) do |what|
+  @output ||= ""
+  expect(@output).to include(what)
+end

data/features/support/env.rb

@@ -0,0 +1,3 @@
+require 'rspec/expectations'
+
+World(RSpec::Expectations)

data/gemfiles/rspec-2

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rspec-json_expectations.gemspec
+gemspec path: '..'
+
+group :test do
+  gem 'cucumber'
+  gem 'rspec', '~> 2.14.0'
+end
+

data/gemfiles/rspec-3

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rspec-json_expectations.gemspec
+gemspec path: '..'
+
+group :test do
+  gem 'cucumber'
+  gem 'rspec', '~> 3.0'
+end
+

data/lib/rspec/json_expectations.rb

@@ -0,0 +1,11 @@
+require "rspec"
+require "rspec/json_expectations/version"
+require "rspec/json_expectations/json_traverser"
+require "rspec/json_expectations/failure_presenter"
+require "rspec/json_expectations/matchers"
+
+module RSpec
+  module JsonExpectations
+    # Your code goes here...
+  end
+end

data/lib/rspec/json_expectations/failure_presenter.rb

@@ -0,0 +1,55 @@
+module RSpec
+  module JsonExpectations
+    # Allows to present failures in a nice way for each json path
+    class FailurePresenter
+      class << self
+        def render(errors)
+          negate = errors[:_negate]
+          errors.map { |path, error| render_error(path, error, negate) }.join
+        end
+
+        private
+
+        def render_error(path, error, negate=false)
+          [
+            render_no_key(path, error, negate),
+            render_not_eq(path, error, negate),
+            render_not_match(path, error, negate)
+          ].select { |e| e }.first
+        end
+
+        def render_no_key(path, error, negate=false)
+          %{
+          json atom at path "#{path}" is missing
+          } if error == :no_key
+        end
+
+        def render_not_eq(path, error, negate=false)
+          %{
+          json atom at path "#{path}" #{negate ? "should" : "is"} not equal to expected value:
+
+            expected: #{error[:expected].inspect}
+                 got: #{error[:actual].inspect}
+          } if error_is_not_eq?(error)
+        end
+
+        def render_not_match(path, error, negate=false)
+          %{
+          json atom at path "#{path}" #{negate ? "should" : "does"} not match expected regex:
+
+            expected: #{error[:expected].inspect}
+                 got: #{error[:actual].inspect}
+          } if error_is_not_match?(error)
+        end
+
+        def error_is_not_eq?(error)
+          error.is_a?(Hash) && error.has_key?(:expected) && !error[:expected].is_a?(Regexp)
+        end
+
+        def error_is_not_match?(error)
+          error.is_a?(Hash) && error.has_key?(:expected) && error[:expected].is_a?(Regexp)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/json_expectations/json_traverser.rb

@@ -0,0 +1,112 @@
+require "json"
+
+module RSpec
+  module JsonExpectations
+    # This class allows to traverse a json actual value along
+    # with json expected value for inclusion and check if they
+    # match. Errors are accumulated in errors hash for each
+    # json atom paths.
+    class JsonTraverser
+      SUPPORTED_VALUES = [Hash, String, Numeric, Regexp, Array]
+
+      class << self
+        def traverse(errors, expected, actual, negate=false, prefix=[])
+          [
+            handle_hash(errors, expected, actual, negate, prefix),
+            handle_array(errors, expected, actual, negate, prefix),
+            handle_value(errors, expected, actual, negate, prefix),
+            handle_regex(errors, expected, actual, negate, prefix),
+            handle_unsupported(expected)
+          ].any?
+        end
+
+        private
+
+        def handle_keyvalue(errors, expected, actual, negate=false, prefix=[])
+          expected.map do |key, value|
+            new_prefix = prefix + [key]
+            if has_key?(actual, key)
+              traverse(errors, value, fetch(actual, key), negate, new_prefix)
+            else
+              errors[new_prefix.join("/")] = :no_key unless negate
+              conditionally_negate(false, negate)
+            end
+          end.all? || false
+        end
+
+        def handle_hash(errors, expected, actual, negate=false, prefix=[])
+          return nil unless expected.is_a?(Hash)
+
+          handle_keyvalue(errors, expected, actual, negate, prefix)
+        end
+
+        def handle_array(errors, expected, actual, negate=false, prefix=[])
+          return nil unless expected.is_a?(Array)
+
+          transformed_expected = expected.each_with_index.map { |v, k| [k, v] }
+          handle_keyvalue(errors, transformed_expected, actual, negate, prefix)
+        end
+
+        def handle_value(errors, expected, actual, negate=false, prefix=[])
+          return nil unless expected.is_a?(String) || expected.is_a?(Numeric)
+
+          if conditionally_negate(actual == expected, negate)
+            true
+          else
+            errors[prefix.join("/")] = {
+              actual: actual,
+              expected: expected
+            }
+            false
+          end
+        end
+
+        def handle_regex(errors, expected, actual, negate=false, prefix=[])
+          return nil unless expected.is_a?(Regexp)
+
+          if conditionally_negate(!!expected.match(actual), negate)
+            true
+          else
+            errors[prefix.join("/")] = {
+              actual: actual,
+              expected: expected
+            }
+            false
+          end
+        end
+
+        def handle_unsupported(expected)
+          unless SUPPORTED_VALUES.any? { |type| expected.is_a?(type) }
+            raise NotImplementedError,
+              "#{expected} expectation is not supported"
+          end
+        end
+
+        def has_key?(actual, key)
+          if actual.is_a?(Hash)
+            actual.has_key?(key.to_s)
+          elsif actual.is_a?(Array)
+            actual.count > key
+          else
+            false
+          end
+        end
+
+        def fetch(actual, key, default=nil)
+          if actual.is_a?(Hash)
+            actual[key.to_s]
+          elsif actual.is_a?(Array)
+            actual[key]
+          else
+            default
+          end
+        end
+
+        def conditionally_negate(value, negate=false)
+          value ^ negate
+        end
+
+      end
+    end
+  end
+end

data/lib/rspec/json_expectations/matchers.rb

@@ -0,0 +1,51 @@
+RSpec::Matchers.define :include_json do |expected|
+
+  # RSpec 2 vs 3
+  if respond_to?(:failure_message)
+    match do |actual|
+      traverse(expected, actual, false)
+    end
+
+    match_when_negated do |actual|
+      traverse(expected, actual, true)
+    end
+
+    failure_message do |actual|
+       RSpec::JsonExpectations::FailurePresenter.render(@include_json_errors)
+    end
+
+    failure_message_when_negated do |actual|
+       RSpec::JsonExpectations::FailurePresenter.render(@include_json_errors)
+    end
+  else
+    match_for_should do |actual|
+      traverse(expected, actual, false)
+    end
+
+    match_for_should_not do |actual|
+      traverse(expected, actual, true)
+    end
+
+    failure_message_for_should do |actual|
+      RSpec::JsonExpectations::FailurePresenter.render(@include_json_errors)
+    end
+
+    failure_message_for_should_not do |actual|
+      RSpec::JsonExpectations::FailurePresenter.render(@include_json_errors)
+    end
+  end
+
+  def traverse(expected, actual, negate=false)
+    unless expected.is_a?(Hash) || expected.is_a?(Array)
+      raise ArgumentError,
+        "Expected value must be a json for include_json matcher"
+    end
+
+    RSpec::JsonExpectations::JsonTraverser.traverse(
+      @include_json_errors = { _negate: negate },
+      expected,
+      JSON.parse(actual),
+      negate
+    )
+  end
+end

data/lib/rspec/json_expectations/version.rb

@@ -0,0 +1,5 @@
+module RSpec
+  module JsonExpectations
+    VERSION = "1.0.0"
+  end
+end

data/local_env.rb

@@ -0,0 +1,3 @@
+After do |s|
+  Cucumber.wants_to_quit = true if s.failed?
+end

data/rspec-json_expectations.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rspec/json_expectations/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rspec-json_expectations"
+  spec.version       = RSpec::JsonExpectations::VERSION
+  spec.authors       = ["Alexey Fedorov"]
+  spec.email         = ["alexey.fedorov@wimdu.com"]
+  spec.summary       = %q{Set of matchers and helpers to allow you test your APIs responses like a pro.}
+  spec.description   = ""
+  spec.homepage      = "https://github.com/waterlink/rspec-json_expectations"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: rspec-json_expectations
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alexey Fedorov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- alexey.fedorov@wimdu.com
+executables:
+- build
+- with-rspec-2
+- with-rspec-3
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/build
+- bin/with-rspec-2
+- bin/with-rspec-3
+- features/rspec/json_expectations/array_support.feature
+- features/rspec/json_expectations/include_json_matcher.feature
+- features/rspec/json_expectations/negation_matching.feature
+- features/rspec/json_expectations/nested_json_support.feature
+- features/rspec/json_expectations/regular_expressions_support.feature
+- features/step_definitions/steps.rb
+- features/support/env.rb
+- gemfiles/rspec-2
+- gemfiles/rspec-3
+- lib/rspec/json_expectations.rb
+- lib/rspec/json_expectations/failure_presenter.rb
+- lib/rspec/json_expectations/json_traverser.rb
+- lib/rspec/json_expectations/matchers.rb
+- lib/rspec/json_expectations/version.rb
+- local_env.rb
+- rspec-json_expectations.gemspec
+homepage: https://github.com/waterlink/rspec-json_expectations
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Set of matchers and helpers to allow you test your APIs responses like a
+  pro.
+test_files:
+- features/rspec/json_expectations/array_support.feature
+- features/rspec/json_expectations/include_json_matcher.feature
+- features/rspec/json_expectations/negation_matching.feature
+- features/rspec/json_expectations/nested_json_support.feature
+- features/rspec/json_expectations/regular_expressions_support.feature
+- features/step_definitions/steps.rb
+- features/support/env.rb
+has_rdoc: