json_spec 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+.rvmrc
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright © 2011 Steve Richert
+
+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,224 @@
+JsonSpec
+========
+Easily handle JSON in RSpec and Cucumber
+
+Installation
+------------
+    gem install json_spec
+
+or with Bundler:
+
+    gem "json_spec"
+
+Documentation
+-------------
+Please help write documentation!
+
+[http://rdoc.info/github/collectiveidea/json_spec](http://rdoc.info/github/collectiveidea/json_spec)
+
+Continuous Integration
+----------------------
+Coming soon…
+
+RSpec
+--------------
+JsonSpec defines four new RSpec matchers:
+
+* `be_json_eql`
+* `have_json_path`
+* `have_json_type`
+* `have_json_size`
+
+The new matchers could be used in RSpec as follows:
+
+    describe User do
+      let(:user){ User.create!(:first_name => "Steve", :last_name => "Richert") }
+
+      context "#to_json" do
+        let(:json){ user.to_json }
+
+        it "includes the name" do
+          json.should be_json_eql(%({"first_name":"Steve","last_name":"Richert"})).excluding("friends")
+        end
+
+        it "includes the ID" do
+          json.should have_json_path("id")
+          json.should have_json_type(Integer).at_path("id")
+        end
+
+        it "includes friends" do
+          json.should have_json_size(0).at_path("friends")
+          user.friends << User.create!(:first_name => "Catie", :last_name => "Richert")
+          json.should have_json_size(1).at_path("friends")
+        end
+      end
+    end
+
+### Exclusions
+
+JsonSpec 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:
+
+    JsonSpec.configure do
+      exclude_keys "created_at", "updated_at"
+    end
+
+Now, the `id` key will be included in JsonSpec'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 JsonSpec'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
+--------
+JsonSpec provides Cucumber steps that utilize its RSpec matchers and that's where JsonSpec 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:
+
+    require "json_spec/cucumber"
+
+You also need to define a `last_json` method. If you're using Capybara, it could be as simple as:
+
+    def last_json
+      page.source
+    end
+
+Now, you can use the JsonSpec steps in your features:
+
+    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 JsonSpec and the "visit" steps are provided by
+Capybara. The remaining steps all stem from the five steps that JsonSpec provides. They're
+versatile and can be used in plenty of different formats:
+
+    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 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 "JSON" above could also be downcased and/or followed by "response."_
+
+Contributing
+------------
+In the spirit of [free software](http://www.fsf.org/licensing/essays/free-sw.html), **everyone** is encouraged to help improve this project.
+
+Here are some ways *you* can contribute:
+
+* using alpha, beta, and prerelease versions
+* reporting bugs
+* suggesting new features
+* writing or editing documentation
+* writing specifications
+* writing code (**no patch is too small**: fix typos, add comments, clean up inconsistent whitespace)
+* refactoring code
+* closing [issues](https://github.com/collectiveidea/json_spec/issues)
+* reviewing patches
+
+Submitting an Issue
+-------------------
+We use the [GitHub issue tracker](https://github.com/collectiveidea/json_spec/issues) to track bugs
+and features. Before submitting a bug report or feature request, check to make sure it hasn't already
+been submitted. You can indicate support for an existing issuse by voting it up. When submitting a
+bug report, please include a [Gist](https://gist.github.com/) that includes a stack trace and any
+details that may be necessary to reproduce the bug, including your gem version, Ruby version, and
+operating system. Ideally, a bug report should include a pull request with failing specs.
+
+Submitting a Pull Request
+-------------------------
+1. Fork the project.
+2. Create a topic branch.
+3. Implement your feature or bug fix.
+4. Add specs for your feature or bug fix.
+5. Run <tt>bundle exec rake</tt>. If your changes are not 100% covered and passing, go back to step 4.
+6. Commit and push your changes.
+7. Submit a pull request. Please do not include changes to the gemspec, version, or history file. (If you want to create your own version for some reason, please do so in a separate commit.)
+
+Copyright
+---------
+Copyright © 2011 Steve Richert
+See [LICENSE](https://github.com/collectiveidea/json_spec/blob/master/LICENSE.md) for details.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "cucumber/rake/task"
+
+RSpec::Core::RakeTask.new(:spec)
+Cucumber::Rake::Task.new(:cucumber)
+
+task :test => [:spec, :cucumber]
+task :default => :test

data/features/equivalence.feature

@@ -0,0 +1,233 @@
+Feature: Equivalence
+  Background:
+    Given the JSON is:
+      """
+      {
+        "array": [
+          "json",
+          "spec"
+        ],
+        "created_at": "2011-07-08 02:27:34",
+        "empty_array": [
+
+        ],
+        "empty_hash": {
+        },
+        "false": false,
+        "float": 10.0,
+        "hash": {
+          "json": "spec"
+        },
+        "id": 1,
+        "integer": 10,
+        "negative": -10,
+        "null": null,
+        "string": "json_spec",
+        "true": true,
+        "updated_at": "2011-07-08 02:28:50"
+      }
+      """
+
+  Scenario: Identical JSON
+    When I get the JSON
+    Then the JSON should be:
+      """
+      {
+        "array": [
+          "json",
+          "spec"
+        ],
+        "created_at": "2011-07-08 02:27:34",
+        "empty_array": [
+
+        ],
+        "empty_hash": {
+        },
+        "false": false,
+        "float": 10.0,
+        "hash": {
+          "json": "spec"
+        },
+        "id": 1,
+        "integer": 10,
+        "negative": -10,
+        "null": null,
+        "string": "json_spec",
+        "true": true,
+        "updated_at": "2011-07-08 02:28:50"
+      }
+      """
+
+  Scenario: Reverse order
+    When I get the JSON
+    Then the JSON should be:
+      """
+      {
+        "updated_at": "2011-07-08 02:28:50",
+        "true": true,
+        "string": "json_spec",
+        "null": null,
+        "negative": -10,
+        "integer": 10,
+        "id": 1,
+        "hash": {
+          "json": "spec"
+        },
+        "float": 10.0,
+        "false": false,
+        "empty_hash": {
+        },
+        "empty_array": [
+
+        ],
+        "created_at": "2011-07-08 02:27:34",
+        "array": [
+          "json",
+          "spec"
+        ]
+      }
+      """
+
+  Scenario: Excluding keys
+    When I get the JSON
+    Then the JSON should be:
+      """
+      {
+        "array": [
+          "json",
+          "spec"
+        ],
+        "empty_array": [
+
+        ],
+        "empty_hash": {
+        },
+        "false": false,
+        "float": 10.0,
+        "hash": {
+          "json": "spec"
+        },
+        "integer": 10,
+        "negative": -10,
+        "null": null,
+        "string": "json_spec",
+        "true": true
+      }
+      """
+
+  Scenario: String
+    When I get the JSON
+    Then the JSON at "string" should be "json_spec"
+    And the JSON at "string" should be:
+      """
+      "json_spec"
+      """
+
+  Scenario: Integer
+    When I get the JSON
+    Then the JSON at "integer" should be 10
+    And the JSON at "integer" should be:
+      """
+      10
+      """
+
+  Scenario: Negative integer
+    When I get the JSON
+    Then the JSON at "negative" should be -10
+    And the JSON at "negative" should be:
+      """
+      -10
+      """
+
+  Scenario: Float
+    When I get the JSON
+    Then the JSON at "float" should be 10.0
+    And the JSON at "float" should be 10.0e0
+    And the JSON at "float" should be 10.0e+0
+    And the JSON at "float" should be 10.0e-0
+    And the JSON at "float" should be 10e0
+    And the JSON at "float" should be 10e+0
+    And the JSON at "float" should be 10e-0
+    And the JSON at "float" should be 1.0e1
+    And the JSON at "float" should be 1.0e+1
+    And the JSON at "float" should be 1e1
+    And the JSON at "float" should be 1e+1
+    And the JSON at "float" should be 100.0e-1
+    And the JSON at "float" should be 100e-1
+    And the JSON at "float" should be:
+      """
+      10.0
+      """
+
+  Scenario: Array
+    When I get the JSON
+    Then the JSON at "array" should be ["json","spec"]
+    And the JSON at "array/0" should be "json"
+    And the JSON at "array/1" should be "spec"
+    And the JSON at "array" should be:
+      """
+      [
+        "json",
+        "spec"
+      ]
+      """
+
+  Scenario: Empty array
+    When I get the JSON
+    Then the JSON at "empty_array" should be []
+    And the JSON at "empty_array" should be:
+      """
+      [
+
+      ]
+      """
+
+  Scenario: Hash
+    When I get the JSON
+    Then the JSON at "hash" should be {"json":"spec"}
+    And the JSON at "hash/json" should be "spec"
+    And the JSON at "hash" should be:
+      """
+      {
+        "json": "spec"
+      }
+      """
+
+  Scenario: Empty hash
+    When I get the JSON
+    Then the JSON at "empty_hash" should be {}
+    And the JSON at "empty_hash" should be:
+      """
+      {
+      }
+      """
+
+  Scenario: True
+    When I get the JSON
+    Then the JSON at "true" should be true
+    And the JSON at "true" should be:
+      """
+      true
+      """
+
+  Scenario: False
+    When I get the JSON
+    Then the JSON at "false" should be false
+    And the JSON at "false" should be:
+      """
+      false
+      """
+
+  Scenario: Null
+    When I get the JSON
+    Then the JSON at "null" should be null
+    And the JSON at "null" should be:
+      """
+      null
+      """
+
+  Scenario: Excluded value
+    When I get the JSON
+    Then the JSON at "created_at" should be "2011-07-08 02:27:34"
+    And the JSON at "id" should be 1
+    And the JSON at "updated_at" should be "2011-07-08 02:28:50"

data/features/paths.feature

@@ -0,0 +1,43 @@
+Feature: Paths
+  Background:
+    Given the JSON is:
+      """
+      {
+        "array": [
+          {
+            "one": 1,
+            "two": 2
+          },
+          {
+            "four": 4,
+            "three": 3
+          }
+        ],
+        "hash": {
+          "even": [
+            6,
+            8
+          ],
+          "odd": [
+            5,
+            7
+          ]
+        },
+        "id": null
+      }
+      """
+
+  Scenario: Nested paths
+    When I get the JSON
+    Then the JSON should have "array/0/one"
+    And the JSON should have "array/0/two"
+    And the JSON should have "array/1/four"
+    And the JSON should have "array/1/three"
+    And the JSON should have "hash/even/0"
+    And the JSON should have "hash/even/1"
+    And the JSON should have "hash/odd/0"
+    And the JSON should have "hash/odd/1"
+
+  Scenario: Ignored paths
+    When I get the JSON
+    Then the JSON should have "id"

data/features/sizes.feature

@@ -0,0 +1,38 @@
+Feature: Sizes
+  Background:
+    Given the JSON is:
+      """
+      {
+        "id": null,
+        "one": [
+          1
+        ],
+        "three": [
+          1,
+          2,
+          3
+        ],
+        "two": [
+          1,
+          2
+        ],
+        "zero": [
+
+        ]
+      }
+      """
+
+  Scenario: Hash
+    When I get the JSON
+    Then the JSON should have 5 keys
+    And the JSON should have 5 values
+
+  Scenario: Empty array
+    When I get the JSON
+    Then the JSON at "zero" should have 0 entries
+
+  Scenario: Array
+    When I get the JSON
+    Then the JSON at "one" should have 1 entry
+    And the JSON at "two" should have 2 values
+    And the JSON at "three" should have 3 numbers

data/features/step_definitions/steps.rb

@@ -0,0 +1,7 @@
+Given "the JSON is:" do |json|
+  @json = json
+end
+
+When "I get the JSON" do
+  @last_json = @json
+end

data/features/support/env.rb

@@ -0,0 +1,6 @@
+$: << File.expand_path("../../../lib", __FILE__)
+require "json_spec/cucumber"
+
+def last_json
+  @last_json.to_s
+end

data/features/types.feature

@@ -0,0 +1,18 @@
+Feature: Types
+  Scenario: All types
+    Given the JSON is:
+      """
+      {
+        "array": [],
+        "float": 10.0,
+        "hash": {},
+        "integer": 10,
+        "string": "json_spec"
+      }
+      """
+    When I get the JSON
+    Then the JSON should be a hash
+    And the JSON at "array" should be an array
+    And the JSON at "float" should be a float
+    And the JSON at "hash" should be a hash
+    And the JSON at "integer" should be an integer

data/json_spec.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "json_spec/version"
+
+Gem::Specification.new do |s|
+  s.name        = "json_spec"
+  s.version     = JsonSpec::VERSION
+  s.authors     = ["Steve Richert"]
+  s.email       = ["steve.richert@gmail.com"]
+  s.homepage    = "https://github.com/collectiveidea/json_spec"
+  s.summary     = "Easily handle JSON in RSpec and Cucumber"
+  s.description = "Easily handle JSON in RSpec and Cucumber"
+
+  s.rubyforge_project = "json_spec"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "json", "~> 1.0"
+  s.add_dependency "rspec", "~> 2.0"
+
+  s.add_development_dependency "cucumber", "~> 1.0"
+end

data/lib/json_spec.rb

@@ -0,0 +1,9 @@
+require "json_spec/version"
+require "json_spec/errors"
+require "json_spec/configuration"
+require "json_spec/matchers"
+require "json_spec/helpers"
+
+module JsonSpec
+  extend Configuration
+end

data/lib/json_spec/configuration.rb

@@ -0,0 +1,27 @@
+require "set"
+
+module JsonSpec
+  module Configuration
+    DEFAULT_EXCLUDED_KEYS = %w(id created_at updated_at)
+
+    def configure(&block)
+      instance_eval(&block)
+    end
+
+    def excluded_keys
+      @excluded_keys ||= DEFAULT_EXCLUDED_KEYS
+    end
+
+    def excluded_keys=(keys)
+      @excluded_keys = keys.map{|k| k.to_s }.uniq
+    end
+
+    def exclude_keys(*keys)
+      self.excluded_keys = keys
+    end
+
+    def reset
+      instance_variables.each{|iv| remove_instance_variable(iv) }
+    end
+  end
+end

data/lib/json_spec/cucumber.rb

@@ -0,0 +1,24 @@
+require File.expand_path("../../json_spec", __FILE__)
+
+World(JsonSpec::Helpers)
+
+Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should be:$/ do |path, json|
+  last_json.should be_json_eql(json).at_path(path)
+end
+
+Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should be (".*"|\-?\d+(?:\.\d+)?(?:[eE][\+\-]?\d+)?|\[.*\]|\{.*\}|true|false|null)$/ do |path, value|
+  last_json.should be_json_eql(value).at_path(path)
+end
+
+Then /^the (?:JSON|json)(?: response)? should have "(.*)"$/ do |path|
+  last_json.should have_json_path(path)
+end
+
+Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should be an? (.*)$/ do |path, type|
+  klass = Module.const_get(type.gsub(/^./){|x| x.upcase })
+  last_json.should have_json_type(klass).at_path(path)
+end
+
+Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should have (\d+)/ do |path, size|
+  last_json.should have_json_size(size.to_i).at_path(path)
+end

data/lib/json_spec/errors.rb

@@ -0,0 +1,13 @@
+module JsonSpec
+  class MissingPathError < StandardError
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def to_s
+      %(Missing JSON path "#{path}")
+    end
+  end
+end

data/lib/json_spec/helpers.rb

@@ -0,0 +1,41 @@
+module JsonSpec
+  module Helpers
+    extend self
+
+    def json_at_path(json, path)
+      pretty_json_value(ruby_at_json_path(json, path))
+    end
+
+    def pretty_json_value(ruby)
+      case ruby
+      when Hash, Array then JSON.pretty_generate(ruby)
+      when NilClass then "null"
+      else ruby.inspect
+      end
+    end
+
+    def ruby_at_json_path(json, path)
+      json_path_to_keys(path).inject(parse_json_value(json)) do |value, key|
+        case value
+        when Hash, Array then value.fetch(key){ missing_json_path!(path) }
+        else missing_json_path!(path)
+        end
+      end
+    end
+
+    def json_path_to_keys(path)
+      path.to_s.gsub(/(?:^\/|\/$)/, "").split("/").map{|k| k =~ /^\d+$/ ? k.to_i : k }
+    end
+
+    def parse_json_value(json)
+      JSON.parse(%({"root":#{json}}))["root"]
+    rescue JSON::ParserError
+      # Re-raise more appropriate parsing error
+      JSON.parse(json)
+    end
+
+    def missing_json_path!(path)
+      raise JsonSpec::MissingPathError.new(path)
+    end
+  end
+end

data/lib/json_spec/matchers.rb

@@ -0,0 +1,113 @@
+require "json"
+require "rspec"
+
+RSpec::Matchers.define :be_json_eql do |expected_json|
+  include JsonSpec::Helpers
+
+  diffable
+
+  match do |actual_json|
+    @actual, @expected = scrub(actual_json, @path), [scrub(expected_json)]
+    @actual == @expected.first
+  end
+
+  chain :at_path do |path|
+    @path = path
+  end
+
+  chain :excluding do |*keys|
+    excluded_keys.add(*keys.map{|k| k.to_s })
+  end
+
+  chain :including do |*keys|
+    excluded_keys.subtract(keys.map{|k| k.to_s })
+  end
+
+  failure_message_for_should do
+    message = "Expected equivalent JSON"
+    message << %( at path "#{@path}") if @path
+    message
+  end
+
+  def scrub(json, path = nil)
+    ruby = path ? ruby_at_json_path(json, path) : parse_json_value(json)
+    pretty_json_value(exclude_keys(ruby)).chomp + "\n"
+  end
+
+  def exclude_keys(ruby)
+    case ruby
+    when Hash
+      ruby.sort.inject({}) do |hash, (key, value)|
+        hash[key] = exclude_keys(value) unless exclude_key?(key)
+        hash
+      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(JsonSpec.excluded_keys)
+  end
+end
+
+RSpec::Matchers.define :have_json_path do |path|
+  include JsonSpec::Helpers
+
+  match do |json|
+    begin
+      ruby_at_json_path(json, path)
+      true
+    rescue JsonSpec::MissingPathError
+      false
+    end
+  end
+
+  failure_message_for_should do
+    %(Expected JSON path "#{path}")
+  end
+end
+
+RSpec::Matchers.define :have_json_type do |klass|
+  include JsonSpec::Helpers
+
+  match do |json|
+    ruby = @path ? ruby_at_json_path(json, @path) : parse_json_value(json)
+    ruby.is_a?(klass)
+  end
+
+  chain :at_path do |path|
+    @path = path
+  end
+
+  failure_message_for_should do
+    message = "Expected JSON value type of #{klass}"
+    message << %( at path "#{@path}") if @path
+    message
+  end
+end
+
+RSpec::Matchers.define :have_json_size do |expected_size|
+  include JsonSpec::Helpers
+
+  match do |json|
+    ruby = @path ? ruby_at_json_path(json, @path) : parse_json_value(json)
+    actual_size = ruby.is_a?(Enumerable) ? ruby.size : 1
+    actual_size == expected_size
+  end
+
+  chain :at_path do |path|
+    @path = path
+  end
+
+  failure_message_for_should do
+    message = "Expected JSON value size of #{expected_size}"
+    message << %( at path "#{@path}") if @path
+    message
+  end
+end

data/lib/json_spec/version.rb

@@ -0,0 +1,3 @@
+module JsonSpec
+  VERSION = "0.1.0"
+end

data/spec/json_spec/configuration_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe JsonSpec::Configuration do
+  it "excludes id and timestamps by default" do
+    JsonSpec.excluded_keys.should == ["id", "created_at", "updated_at"]
+  end
+
+  it "excludes custom keys" do
+    JsonSpec.exclude_keys("token")
+    JsonSpec.excluded_keys.should == ["token"]
+  end
+
+  it "excludes custom keys via setter" do
+    JsonSpec.excluded_keys = ["token"]
+    JsonSpec.excluded_keys.should == ["token"]
+  end
+
+  it "excludes custom keys via block" do
+    JsonSpec.configure{|c| c.exclude_keys("token") }
+    JsonSpec.excluded_keys.should == ["token"]
+  end
+
+  it "excludes custom keys via block setter" do
+    JsonSpec.configure{|c| c.excluded_keys = ["token"] }
+    JsonSpec.excluded_keys.should == ["token"]
+  end
+
+  it "excludes custom keys via instance-evaluated block" do
+    JsonSpec.configure{ exclude_keys("token") }
+    JsonSpec.excluded_keys.should == ["token"]
+  end
+
+  it "ensures its excluded keys are strings" do
+    JsonSpec.exclude_keys(:token)
+    JsonSpec.excluded_keys.should == ["token"]
+  end
+
+  it "ensures its excluded keys are unique" do
+    JsonSpec.exclude_keys("token", :token)
+    JsonSpec.excluded_keys.should == ["token"]
+  end
+
+  it "resets its excluded keys" do
+    original = JsonSpec.excluded_keys
+
+    JsonSpec.exclude_keys("token")
+    JsonSpec.excluded_keys.should_not == original
+
+    JsonSpec.reset
+    JsonSpec.excluded_keys.should == original
+  end
+end

data/spec/json_spec/matchers_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+describe "Matchers:" do
+  context "be_json_eql" do
+    it "matches identical JSON" do
+      %({"json":"spec"}).should be_json_eql(%({"json":"spec"}))
+    end
+
+    it "matches differently-formatted JSON" do
+      %({"json": "spec"}).should be_json_eql(%({"json":"spec"}))
+    end
+
+    it "matches out-of-order hashes" do
+      %({"laser":"lemon","json":"spec"}).should be_json_eql(%({"json":"spec","laser":"lemon"}))
+    end
+
+    it "doesn't match out-of-order arrays" do
+      %(["json","spec"]).should_not be_json_eql(%(["spec","json"]))
+    end
+
+    it "ignores excluded-by-default hash keys" do
+      JsonSpec.excluded_keys.should_not be_empty
+
+      actual = expected = {"json" => "spec"}
+      JsonSpec.excluded_keys.each{|k| actual[k] = k }
+      actual.to_json.should be_json_eql(expected.to_json)
+    end
+
+    it "ignores custom excluded hash keys" do
+      JsonSpec.exclude_keys("ignore")
+      %({"json":"spec","ignore":"please"}).should be_json_eql(%({"json":"spec"}))
+    end
+
+    it "ignores nested, excluded hash keys" do
+      JsonSpec.exclude_keys("ignore")
+      %({"json":"spec","please":{"ignore":"this"}}).should be_json_eql(%({"json":"spec","please":{}}))
+    end
+
+    it "ignores hash keys when included in the expected value" do
+      JsonSpec.exclude_keys("ignore")
+      %({"json":"spec","ignore":"please"}).should be_json_eql(%({"json":"spec","ignore":"this"}))
+    end
+
+    it "doesn't match Ruby-equivalent, JSON-inequivalent values" do
+      %({"one":1}).should_not be_json_eql(%({"one":1.0}))
+    end
+
+    it "excludes extra hash keys per matcher" do
+      JsonSpec.excluded_keys = %w(ignore)
+      %({"id":1,"json":"spec","ignore":"please"}).should be_json_eql(%({"id":"2","json":"spec","ignore":"this"})).excluding("id")
+    end
+
+    it "excludes extra hash keys given as symbols" do
+      JsonSpec.excluded_keys = []
+      %({"id":1,"json":"spec"}).should be_json_eql(%({"id":2,"json":"spec"})).excluding(:id)
+    end
+
+    it "includes globally-excluded hash keys per matcher" do
+      JsonSpec.excluded_keys = %w(id ignore)
+      %({"id":1,"json":"spec","ignore":"please"}).should_not be_json_eql(%({"id":"2","json":"spec","ignore":"this"})).including("id")
+    end
+
+    it "includes globally-included hash keys given as symbols" do
+      JsonSpec.excluded_keys = %w(id)
+      %({"id":1,"json":"spec"}).should_not be_json_eql(%({"id":2,"json":"spec"})).including(:id)
+    end
+  end
+
+  context "have_json_size" do
+    it "counts array entries" do
+      %([1,2,3]).should have_json_size(3)
+    end
+
+    it "counts null array entries" do
+      %([1,null,3]).should have_json_size(3)
+    end
+
+    it "counts hash key/value pairs" do
+      %({"one":1,"two":2,"three":3}).should have_json_size(3)
+    end
+
+    it "counts null hash values" do
+      %({"one":1,"two":null,"three":3}).should have_json_size(3)
+    end
+  end
+
+  context "have_json_path" do
+    it "matches hash keys" do
+      %({"one":{"two":{"three":4}}}).should have_json_path("one/two/three")
+    end
+
+    it "doesn't match values" do
+      %({"one":{"two":{"three":4}}}).should_not have_json_path("one/two/three/4")
+    end
+
+    it "matches array indexes" do
+      %([1,[1,2,[1,2,3,4]]]).should have_json_path("1/2/3")
+    end
+
+    it "respects null array values" do
+      %([null,[null,null,[null,null,null,null]]]).should have_json_path("1/2/3")
+    end
+
+    it "matches hash keys and array indexes" do
+      %({"one":[1,2,{"three":4}]}).should have_json_path("one/2/three")
+    end
+  end
+end

data/spec/json_spec_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe JsonSpec do
+  it "is awesome"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require "json_spec"
+
+RSpec.configure do |config|
+  config.before do
+    JsonSpec.reset
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: json_spec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Steve Richert
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-08 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &2153487840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153487840
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2153487340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153487340
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &2153486880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153486880
+description: Easily handle JSON in RSpec and Cucumber
+email:
+- steve.richert@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- features/equivalence.feature
+- features/paths.feature
+- features/sizes.feature
+- features/step_definitions/steps.rb
+- features/support/env.rb
+- features/types.feature
+- json_spec.gemspec
+- lib/json_spec.rb
+- lib/json_spec/configuration.rb
+- lib/json_spec/cucumber.rb
+- lib/json_spec/errors.rb
+- lib/json_spec/helpers.rb
+- lib/json_spec/matchers.rb
+- lib/json_spec/version.rb
+- spec/json_spec/configuration_spec.rb
+- spec/json_spec/matchers_spec.rb
+- spec/json_spec_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/collectiveidea/json_spec
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: json_spec
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Easily handle JSON in RSpec and Cucumber
+test_files:
+- features/equivalence.feature
+- features/paths.feature
+- features/sizes.feature
+- features/step_definitions/steps.rb
+- features/support/env.rb
+- features/types.feature
+- spec/json_spec/configuration_spec.rb
+- spec/json_spec/matchers_spec.rb
+- spec/json_spec_spec.rb
+- spec/spec_helper.rb