json_assert 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in json_assert.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright © 2011 Frazer Horn
+
+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,30 @@
+json_assert
+========
+Easily handle JSON in Test::Unit.  
+This is completely copied from the excellent json_spec gem found here https://github.com/collectiveidea/json_spec
+I just wanted the same features for a project where rspec was not available
+
+Installation
+------------
+    gem install json_assert
+
+or with Bundler:
+
+    gem "json_assert"
+
+Documentation
+-------------
+
+json_assert defines six new assertions:
+
+* `assert_json_eql`
+* `assert_part_json`
+* `assert_include_json`
+* `assert_json_path`
+* `assert_json_type`
+* `assert_json_size`
+
+Copyright
+---------
+Copyright © 2011 Frazer Horn
+See [LICENSE](https://github.com/frazerh/json_assert/blob/master/LICENSE.md) for details.

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.test_files = FileList['test/*_test.rb']
+  test.verbose = true
+  # test.warning = true
+end
+
+namespace :test do
+  Rake::TestTask.new(:unit) do |test|
+    test.libs << 'lib' << 'test'
+    test.pattern = 'test/*_test.rb'
+    test.verbose = true
+  end
+end

data/json_assert.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "json_assert/version"
+
+Gem::Specification.new do |s|
+  s.name        = "json_assert"
+  s.version     = JsonAssert::VERSION
+  s.authors     = ["Frazer Horn"]
+  s.email       = ["frazer.horn@gmail.com"]
+  s.homepage    = "https://github.com/frazerh/json_assert"
+  s.summary     = %q{Easily handle JSON in Test::Unit}
+  s.description = %q{Easily handle JSON in Test::Unit}
+
+  s.rubyforge_project = "json_assert"
+
+  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 "multi_json", "~> 1.0.0"
+  s.add_development_dependency "rake", "~> 0.9"
+
+end

data/lib/json_assert/assertions.rb

@@ -0,0 +1,139 @@
+require "json"
+require 'active_support/core_ext/hash/diff'
+
+module JsonAssert
+  module Assertions
+
+    include JsonAssert::Helpers
+    include JsonAssert::Exclusion
+
+    def assert_json_eql(actual_json, expected_json, options={})
+      parse_options(options)
+      actual, expected = scrub(actual_json, @path), [scrub(expected_json)]
+      msg = build_message(@message, "<?> expected to be equal to\n<?>.", expected.inspect, actual.inspect)
+      assert_block(msg) { actual == expected.first }
+    end
+
+    def assert_json_not_eql(actual_json, expected_json, options={})
+      parse_options(options)
+      actual, expected = scrub(actual_json, @path), [scrub(expected_json)]
+      msg = build_message(@message, "<?> expected not to be equal to\n<?>.", expected.to_s, actual.to_s)
+      assert_block(msg) { actual != expected.first }
+    end
+
+    def assert_include_json(actual_json, expected_json, options={})
+      parse_options(options)
+      actual = parse_json(actual_json, @path)
+      expected = exclude_keys(parse_json(expected_json))
+      msg = build_message(@message, "<?> expected to include\n<?>.", expected.to_s, actual.to_s)
+      assert_block(msg) {
+        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)
+        else false
+        end
+      }
+    end
+
+    def assert_json_path(json, path)
+      msg = "path was not found for #{path}"
+      assert_block(msg) do
+        begin
+          parse_json(json, path)
+          true
+        rescue JsonAssert::MissingPathError
+          false
+        end
+      end
+    end
+    
+    def assert_not_json_path(json, path)
+      msg = "path was unexpectedly found for #{path}"
+      assert_block(msg) do
+        begin
+          parse_json(json, path)
+          false
+        rescue JsonAssert::MissingPathError
+          true
+        end
+      end
+    end
+    
+    def assert_part_json(json, json_part, options={})
+      parse_options(options)
+      @json = parse_json(json, @path)
+      @json_part = parse_json(json_part)
+      msg = build_message(@message, "<?> was not part of \n<?>.", @json_part.to_s, @json.to_s)
+      assert_block(msg){ find_part_json == true }
+    end
+    
+    def assert_not_part_json(json, json_part, options={})
+      parse_options(options)
+      @json = parse_json(json, @path)
+      @json_part = parse_json(json_part)
+      msg = build_message(@message, "<?> was unexpectedly part of \n<?>.", @json_part.to_s, @json.to_s)
+      assert_block(msg){ !find_part_json }
+    end
+
+    def assert_json_type(json, klass, options={})
+      parse_options(options)
+      actual = parse_json(json, @path)
+      msg = build_message(@message, "<?> expected to be a\n<?>.", actual.to_s, klass.to_s)
+      assert_block(msg) { actual.is_a?(klass) }
+    end
+
+    def assert_json_size(json, expected_size, options={})
+      parse_options(options)
+      @json = json
+      size = actual_size
+      msg = build_message(@message, "expected size was <?> but it was <?>.", expected_size.to_s, size.to_s)
+      assert_block(msg) { size == expected_size }
+    end
+
+    private
+
+      def parse_options(options)
+        @message = options.delete(:message) 
+        options.each{|k,v| self.send(k.to_s, v) }
+      end
+
+      def scrub(json, path = nil)
+        generate_normalized_json(exclude_keys(parse_json(json, path))).chomp + "\n"
+      end
+
+      def excluding(*keys)
+        excluded_keys.merge(keys.flatten.map{|k| k.to_s })
+      end
+
+      def including(*keys)
+        excluded_keys.subtract(keys.map{|k| k.to_s })
+      end
+
+      def at_path(path)
+        @path = path
+      end
+
+      def actual_size
+        ruby = parse_json(@json, @path)
+        ruby.is_a?(Enumerable) ? ruby.size : 1
+      end
+      
+      def find_part_json
+        @json_part.each do |k,v|
+         return false unless find_key_value_pair(@json, k,v)
+        end
+        return true
+      end
+
+      def find_key_value_pair(json, key, value)
+        json.each do |k, v|
+          return true if k == key && v==value
+          if v.is_a?(Hash)
+            return true if find_key_value_pair(v, key, value)
+          end
+        end
+        return false
+      end
+
+  end
+end

data/lib/json_assert/config.rb

@@ -0,0 +1,27 @@
+require "set"
+
+module JsonAssert
+  module Config
+    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_assert/errors.rb

@@ -0,0 +1,13 @@
+module JsonAssert
+  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_assert/exclusions.rb

@@ -0,0 +1,26 @@
+module JsonAssert
+  module Exclusion
+    extend self
+
+    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(JsonAssert.excluded_keys)
+    end
+  end
+end

data/lib/json_assert/helpers.rb

@@ -0,0 +1,54 @@
+require 'multi_json'
+
+module JsonAssert
+  module Helpers
+
+    extend self
+
+    def parse_json(json, path = nil)
+      ruby = MultiJson.decode(%([#{json}])).first
+      value_at_json_path(ruby, path)
+    rescue MultiJson::DecodeError
+      MultiJson.decode(json)
+    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 then JSON.pretty_generate(ruby)
+      else ruby.to_json
+      end
+    end
+    
+    private
+
+      def value_at_json_path(ruby, path)
+        return ruby unless path
+
+        json_path_to_keys(path).inject(ruby) 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.split("/").map{|k| k =~ /^\d+$/ ? k.to_i : k }
+      end
+
+      def missing_json_path!(path)
+        raise JsonAssert::MissingPathError.new(path)
+      end
+    
+  end
+end
+
+
+
+
+

data/lib/json_assert/version.rb

@@ -0,0 +1,3 @@
+module JsonAssert
+  VERSION = "0.0.1"
+end

data/lib/json_assert.rb

@@ -0,0 +1,11 @@
+require "json_assert/version"
+require "json_assert/errors"
+require "json_assert/config"
+require "json_assert/exclusions"
+require "json_assert/helpers"
+require "json_assert/assertions"
+
+module JsonAssert
+  # Your code goes here...
+  extend Config
+end

data/test/assertions_eql_test.rb

@@ -0,0 +1,62 @@
+require "test_helper"
+
+class AssertionsEqlTest < Test::Unit::TestCase
+  
+  include JsonAssert::Assertions
+  
+  def test_identical_json
+    assert_json_eql %({"json":"spec"}), %({"json":"spec"})
+  end
+  
+  def test_differently_formatted_json
+    assert_json_eql %({"json": "spec"}), %({"json":"spec"})
+  end
+
+  def test_out_of_order_hashes
+    assert_json_eql %({"laser":"lemon","json":"spec"}), %({"json":"spec","laser":"lemon"})
+  end
+
+  def test_does_not_match_out_of_order_arrays
+    assert_json_not_eql %(["json","spec"]), %(["spec","json"])
+  end
+
+  def test_valid_json_values_yet_invalid_json_documents
+    assert_json_eql %("json_spec"), %("json_spec")
+  end
+
+  def test_ignores_custom_excluded_hash_keys
+    JsonAssert.exclude_keys("ignore")
+    assert_json_eql %({"json":"spec","ignore":"please"}), %({"json":"spec"})
+  end
+  
+  def test_excludes_extra_hash_keys_per_matcher
+    JsonAssert.excluded_keys = %w(ignore)
+    assert_json_eql %({"id":1,"json":"spec","ignore":"please"}), %({"id":2,"json":"spec","ignore":"this"}), :excluding => "id"
+  end
+  
+  def test_excludes_extra_hash_keys_given_as_symbols
+    JsonAssert.excluded_keys = []
+    assert_json_eql %({"id":1,"json":"spec"}), %({"id":2,"json":"spec"}), :excluding => :id
+  end
+
+  def test_excludes_multiple_keys
+    JsonAssert.excluded_keys = []
+    assert_json_eql %({"id":1,"json":"spec"}), %({"id":2,"json":"different"}), :excluding => [:id, :json]
+  end
+
+  def test_includes_globally_excluded_hash_keys_per_matcher
+    JsonAssert.excluded_keys = %w(id ignore)
+    assert_json_not_eql %({"id":1,"json":"spec","ignore":"please"}), %({"id":2,"json":"spec","ignore":"this"}), :including => "id"
+  end
+
+  def test_includes_globally_included_hash_keys_given_as_symbols
+    JsonAssert.excluded_keys = %w(id)
+    assert_json_not_eql %({"id":1,"json":"spec"}), %({"id":2,"json":"spec"}), :including => :id
+  end
+
+  def test_includes_multiple_keys
+    JsonAssert.excluded_keys = %w(id json)
+    assert_json_eql %({"id":1,"json":"spec"}), %({"id":2,"json":"different"}), :including => [:id, :json]
+  end
+  
+end

data/test/assertions_include_test.rb

@@ -0,0 +1,71 @@
+require "test_helper"
+
+class AssertionsIncludeTest < Test::Unit::TestCase
+  
+  include JsonAssert::Assertions
+  
+  def test_included_array_elements
+    json = %(["one",1,1.0,true,false,null])
+    assert_include_json json, %("one")
+    assert_include_json json, %(1)
+    assert_include_json json, %(1.0)
+    assert_include_json json, %(true)
+    assert_include_json json, %(false)
+    assert_include_json json, %(null)
+  end
+  
+  def test_an_array_included_in_an_array
+    json = %([[1,2,3],[4,5,6]])
+    assert_include_json(json, %([1,2,3]))
+    assert_include_json(json, %([4,5,6]))
+  end
+
+  def test_test_a_hash_included_in_an_array
+    json = %([{"one":1},{"two":2}])
+    assert_include_json json, %({"one":1})
+    assert_include_json json, %({"two":2})
+  end
+  
+  def test_an_array_included_in_an_array
+     json = %([[1,2,3],[4,5,6]])
+     assert_include_json json, %([1,2,3])
+     assert_include_json json, %([4,5,6])
+   end
+
+   def test_a_hash_included_in_an_array
+     json = %([{"one":1},{"two":2}])
+     assert_include_json json, %({"one":1})
+     assert_include_json json, %({"two":2})
+   end
+
+   def test_include_hash_values
+     json = %({"string":"one","integer":1,"float":1.0,"true":true,"false":false,"null":null})
+     assert_include_json json, %("one")
+     assert_include_json json, %(1)
+     assert_include_json json, %(1.0)
+     assert_include_json json, %(true)
+     assert_include_json json, %(false)
+     assert_include_json json, %(null)
+   end
+
+   def test_a_hash_included_in_a_hash
+     json = %({"one":{"two":3},"four":{"five":6}})
+     assert_include_json json, %({"two":3})
+     assert_include_json json, %({"five":6})
+   end
+
+   def test_an_array_included_in_a_hash
+     json = %({"one":[2,3],"four":[5,6]})
+     assert_include_json json, %([2,3])
+     assert_include_json json, %([5,6])
+   end
+
+   def test_at_a_path
+     assert_include_json %({"one":{"two":[3,4]}}), %([3,4]), :at_path => "one"
+   end
+
+   def test_ignores_excluded_keys
+     assert_include_json %([{"id":1,"two":3}]), %({"two":3})
+   end
+  
+end

data/test/assertions_part_test.rb

@@ -0,0 +1,25 @@
+require "test_helper"
+
+class AssertionsEqlTest < Test::Unit::TestCase
+
+  include JsonAssert::Assertions
+
+  def test_simple_json
+    assert_part_json %({"json":"assert","some":"other"}), %({"json":"assert"})
+  end
+
+  def test_nested_json
+    assert_part_json %({"test":{"assert":"this"},"some":"other"}), %({"assert":"this"})
+  end
+
+  def test_multiple_json
+    assert_part_json %({"test":"x", "assert":"this","some":"other","beta":7}), %({"assert":"this", "beta":7})
+  end
+
+  def test_not_part_of_json
+    assert_not_part_json %({"json":"assert","some":"other"}), %({"sdsdsd":"sdsd"})
+  end
+
+  # TODO: What about arrays
+
+end

data/test/assertions_path_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+class AssertionsPathTest < Test::Unit::TestCase
+
+  include JsonAssert::Assertions
+
+  def test_hash_keys
+    assert_json_path %({"one":{"two":{"three":4}}}),  "one/two/three"
+  end
+
+  def test_doesnt_match_values
+    assert_not_json_path %({"one":{"two":{"three":4}}}), "one/two/three/4"
+  end
+
+  def test_array_indexes
+    assert_json_path %([1,[1,2,[1,2,3,4]]]), "1/2/3"
+  end
+
+  def test_respects_null_array_values
+    assert_json_path %([null,[null,null,[null,null,null,null]]]), "1/2/3"
+  end
+
+  def test_hash_keys_and_array_indexes
+    assert_json_path %({"one":[1,2,{"three":4}]}), "one/2/three"
+  end
+
+end

data/test/assertions_size_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+class AssertionsSizeTest < Test::Unit::TestCase
+
+  include JsonAssert::Assertions
+
+  def test_counts_array_entries
+    assert_json_size %([1,2,3]), 3
+  end
+
+  def test_counts_null_array_entries
+    assert_json_size %([1,null,3]), 3
+  end
+
+  def test_counts_hash_key_value_pairs
+    assert_json_size %({"one":1,"two":2,"three":3}), 3
+  end
+
+  def test_counts_null_hash_values
+    assert_json_size %({"one":1,"two":null,"three":3}), 3
+  end
+
+  def test_at_a_path
+    assert_json_size %({"one":[1,2,3]}), 3, :at_path => "one"
+  end
+
+end

data/test/assertions_type_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class AssertionsTypeTest < Test::Unit::TestCase
+
+  include JsonAssert::Assertions
+
+  def test_hashes
+    assert_json_type %({}), Hash
+  end
+
+  def test_arrays
+    assert_json_type %([]), Array
+  end
+
+  def test_type_at_a_path
+    assert_json_type %({"root":[]}), Array, :at_path => "root"
+  end
+
+  def test_strings
+    assert_json_type %(["json_spec"]), String, :at_path => "0"
+  end
+
+  def test_a_valid_json_value_yet_invalid_json_document
+    assert_json_type %("json_spec"), String
+  end
+
+  def test_empty_strings
+    assert_json_type %(""), String
+  end
+
+  def test_integers
+    assert_json_type %(10), Integer
+  end
+
+  def test_floats
+    assert_json_type %(10.0), Float
+    assert_json_type %(1e+1), Float
+  end
+
+  def test_ancestor_classes
+    assert_json_type %(10), Numeric
+    assert_json_type %(10.0), Numeric
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+puts(if Object.const_defined? :RUBY_DESCRIPTION
+  RUBY_DESCRIPTION
+else
+  "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE} patchlevel #{RUBY_PATCHLEVEL}) [#{RUBY_PLATFORM}]"
+end)
+
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{dir}/../lib"
+
+require 'rubygems'
+require 'test/unit'
+require "pp"
+require "json_assert"

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: json_assert
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Frazer Horn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-24 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &2168527320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2168527320
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2168526700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: *2168526700
+description: Easily handle JSON in Test::Unit
+email:
+- frazer.horn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- json_assert.gemspec
+- lib/json_assert.rb
+- lib/json_assert/assertions.rb
+- lib/json_assert/config.rb
+- lib/json_assert/errors.rb
+- lib/json_assert/exclusions.rb
+- lib/json_assert/helpers.rb
+- lib/json_assert/version.rb
+- test/assertions_eql_test.rb
+- test/assertions_include_test.rb
+- test/assertions_part_test.rb
+- test/assertions_path_test.rb
+- test/assertions_size_test.rb
+- test/assertions_type_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/frazerh/json_assert
+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_assert
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Easily handle JSON in Test::Unit
+test_files:
+- test/assertions_eql_test.rb
+- test/assertions_include_test.rb
+- test/assertions_part_test.rb
+- test/assertions_path_test.rb
+- test/assertions_size_test.rb
+- test/assertions_type_test.rb
+- test/test_helper.rb