assert_json 0.0.3 → 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+Gemfile.lock
+

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use --create 1.9.2@assert_json
+

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    assert_json (0.0.3)
+      activesupport
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.7)
+    minitest (2.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  assert_json!
+  minitest

data/README.md

@@ -1,19 +1,25 @@
-AssertJson
-==========
+# AssertJson #
 
-A gem to test JSON strings.
+Test your JSON strings.
 
-Installation
-------------
+## Installation ##
 
-  cd path/to/your/rails-project
-  ./script/plugin install git://github.com/xing/assert_json.git
+```sh
+cd path/to/your/rails-project
+./script/plugin install git://github.com/xing/assert_json.git
+```
+
+Or if you prefer [bundler](http://getbundler.com)
+
+```sh
+# in your Gemfile
+gem 'assert_json'
+```
 
 
-Usage
------
+## Usage ##
 
-``` ruby
+```ruby
 class MyActionTest < ActionController::TestCase
   include AssertJson
 
@@ -22,30 +28,27 @@ class MyActionTest < ActionController::TestCase
     # => @response.body= '{"key":[{"inner_key1":"value1"},{"inner_key2":"value2"}]}'
     
     assert_json(@response.body) do |json|
-      json.element 'key' do
-        json.element 'inner_key1', 'value1'
-        json.element 'inner_key2', 'value2'
+      has 'key' do
+        has 'inner_key1', 'value1'
+        has 'inner_key2', /lue2/
       end
-      json.not_element 'key_not_included'
+      has_not 'key_not_included'
     end
   end
 
 end
 ```
 
-Authors
--------
+## Authors ##
 
 [Thorsten Böttger](http://github.com/alto),
-[Andree Wille](http://github.com/dreewill),
 [Ralph von der Heyden](http://github.com/ralph)
 
 Please find out more about our work in our 
 [Xing Dev Blog](http://devblog.xing.com/).
 
 
-License
--------
+## License ##
 
 The MIT License
  

data/Rakefile

@@ -1,13 +1,13 @@
+require 'rubygems'
 require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-desc 'Default: run unit tests.'
-task :default => :test
+require 'bundler/gem_tasks'
 
+require 'rake/testtask'
 desc 'Test the assert_json plugin.'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = true
 end
+desc 'Default: run unit tests.'
+task :default => :test

data/assert_json.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "assert_json/version"
+
+Gem::Specification.new do |s|
+  s.name = "assert_json"
+  s.version = AssertJson::VERSION
+  s.summary = "A gem to test JSON strings."
+  s.description = "A gem to test JSON strings."
+  s.files = Dir["{app,lib,config}/**/*"] + ["MIT-LICENSE", "Rakefile", "Gemfile", "README.md"]
+
+  s.authors = ["Thorsten Böttger", "Ralph von der Heyden"]
+  s.email = %q{boettger@mt7.de}
+  s.homepage = %q{https://github.com/xing/assert_json}
+
+  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 'activesupport'
+  s.add_development_dependency 'minitest'
+end

data/lib/assert_json/assert_json.rb

@@ -0,0 +1,80 @@
+module AssertJson
+  
+  def assert_json(json_string, &block)
+    if block_given?
+      json = AssertJson::Json.new(json_string)
+      json.instance_exec(json, &block)
+    end
+  end
+
+  class Json
+    
+    def initialize(json_string)
+      @decoded_json = ActiveSupport::JSON.decode(json_string)
+    end
+    
+    def element(*args, &block)
+      arg = args.shift
+      token = @decoded_json.is_a?(Array) ? @decoded_json.shift : @decoded_json
+      case token
+      when Hash
+        raise_error("element #{arg} not found") unless token.keys.include?(arg)
+        if second_arg = args.shift
+          case second_arg
+          when Regexp
+            raise_error("element #{token[arg].inspect} does not match #{second_arg.inspect}") if second_arg !~ token[arg]
+          else
+            raise_error("element #{token[arg].inspect} does not match #{second_arg.inspect}") if second_arg != token[arg]
+          end
+        end
+      when Array
+        raise_error("element #{arg} not found") if token != arg
+      when String
+        case arg
+        when Regexp
+          raise_error("element #{arg.inspect} not found") if token !~ arg
+        else
+          raise_error("element #{arg.inspect} not found") if token != arg
+        end
+      when NilClass
+        raise_error("no element left")
+      else
+        flunk
+      end
+    
+      if block_given?
+        begin
+          in_scope, @decoded_json = @decoded_json, token.is_a?(Hash) ? token[arg] : token
+          yield
+        ensure
+          @decoded_json = in_scope
+        end
+      end
+      
+    end
+    alias has element
+    
+    def not_element(*args, &block)
+      arg = args.shift
+      token = @decoded_json
+      case token
+      when Array
+        raise_error("element #{arg} found, but not expected") if token.include?(arg)
+      else
+        raise_error("element #{arg} found, but not expected") if token.keys.include?(arg)
+      end
+    end
+    alias has_not not_element
+    
+    private
+    
+      def raise_error(message)
+        if Object.const_defined?(:MiniTest)
+          raise MiniTest::Assertion.new(message)
+        else
+          raise Test::Unit::AssertionFailedError.new(message)
+        end
+      end
+    
+  end
+end

data/lib/assert_json/version.rb

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

data/lib/assert_json.rb

@@ -1,65 +1,2 @@
-module AssertJson
-  
-  def assert_json(json_string, &block)
-    if block_given?
-      yield AssertJson::Json.new(json_string)
-    end
-  end
-
-  class Json
-    
-    def initialize(json_string)
-      @decoded_json = ActiveSupport::JSON.decode(json_string)
-    end
-    
-    def element(*args, &block)
-      arg = args.shift
-      token = @decoded_json.is_a?(Array) ? @decoded_json.shift : @decoded_json
-      case token
-      when Hash
-        raise_error("element #{arg} not found") unless token.keys.include?(arg)
-        if second_arg = args.shift
-          raise_error("element #{token[arg].inspect} does not match #{second_arg.inspect}") if second_arg != token[arg]
-        end
-      when String, Array
-        raise_error("element #{arg} not found") if token != arg
-      when NilClass
-        raise_error("no element left")
-      else
-        flunk
-      end
-    
-      if block_given?
-        begin
-          in_scope, @decoded_json = @decoded_json, token.is_a?(Hash) ? token[arg] : token
-          yield
-        ensure
-          @decoded_json = in_scope
-        end
-      end
-      
-    end
-    
-    def not_element(*args, &block)
-      arg = args.shift
-      token = @decoded_json
-      case token
-      when Array
-        raise_error("element #{arg} found, but not expected") if token.include?(arg)
-      else
-        raise_error("element #{arg} found, but not expected") if token.keys.include?(arg)
-      end
-    end
-    
-    private
-    
-      def raise_error(message)
-        if Object.const_defined?(:MiniTest)
-          raise MiniTest::Assertion.new(message)
-        else
-          raise Test::Unit::AssertionFailedError.new(message)
-        end
-      end
-    
-  end
-end
+require 'assert_json/version'
+require 'assert_json/assert_json'

data/test/assert_json_new_dsl_test.rb

@@ -0,0 +1,268 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class AssertJsonNewDslTest < Test::Unit::TestCase
+  include AssertJson
+
+  def test_string
+    assert_json '"key"' do
+      has 'key'
+    end
+  end
+  def test_string_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '"key"' do
+        has 'wrong_key'
+      end
+    end
+  end
+  def test_regular_expression_for_strings
+    assert_json '"string"' do
+      has /tri/
+    end
+  end
+  def test_regular_expression_for_hash_values
+    assert_json '{"key":"value"}' do
+      has 'key', /alu/
+    end
+  end
+  
+  def test_single_hash
+    assert_json '{"key":"value"}' do
+      has 'key', 'value'
+    end
+  end
+  def test_single_hash_crosscheck_for_key
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":"value"}' do
+        has 'wrong_key', 'value'
+      end
+    end
+  end
+  def test_single_hash_crosscheck_for_value
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":"value"}' do
+        has 'key', 'wrong_value'
+      end
+    end
+  end
+  
+  def test_has_not
+    assert_json '{"key":"value"}' do
+      has 'key', 'value'
+      has_not 'key_not_included'
+    end
+  end
+  def test_has_not_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":"value"}' do
+        has_not 'key'
+      end
+    end
+  end
+  
+  def test_array
+    assert_json '["value1","value2","value3"]' do
+      has 'value1'
+      has 'value2'
+      has 'value3'
+    end
+  end
+  def test_has_not_array
+    assert_json '["value1","value2"]' do
+      has 'value1'
+      has 'value2'
+      has_not 'value3'
+    end
+  end
+  def test_array_crosscheck_order
+    assert_raises(MiniTest::Assertion) do
+      assert_json '["value1","value2","value3"]' do
+        has 'value2'
+      end
+    end
+  end
+  def test_array_crosscheck_for_first_item
+    assert_raises(MiniTest::Assertion) do
+      assert_json '["value1","value2","value3"]' do
+        has 'wrong_value1'
+      end
+    end
+  end
+  def test_array_crosscheck_for_second_item
+    assert_raises(MiniTest::Assertion) do
+      assert_json '["value1","value2","value3"]' do
+        has 'value1'
+        has 'wrong_value2'
+      end
+    end
+  end
+  
+  def test_nested_arrays
+    assert_json '[[["deep","another_depp"],["second_deep"]]]' do
+      has [["deep","another_depp"],["second_deep"]]
+    end
+  end
+  def test_nested_arrays_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '[[["deep","another_depp"],["second_deep"]]]' do
+        has [["deep","wrong_another_depp"],["second_deep"]]
+      end
+    end
+    assert_raises(MiniTest::Assertion) do
+      assert_json '[[["deep","another_depp"],["second_deep"]]]' do
+        has [["deep","another_depp"],["wrong_second_deep"]]
+      end
+    end
+  end
+  
+  def test_hash_with_value_array
+    assert_json '{"key":["value1","value2"]}' do
+      has 'key', ['value1', 'value2']
+    end
+  end
+  def test_hash_with_value_array_crosscheck_wrong_key
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":["value1","value2"]}' do
+        has 'wrong_key', ['value1', 'value2']
+      end
+    end
+  end
+  def test_hash_with_value_array_crosscheck_wrong_value1
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":["value1","value2"]}' do
+        has 'key', ['wrong_value1', 'value2']
+      end
+    end
+  end
+  def test_hash_with_value_array_crosscheck_wrong_value2
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":["value1","value2"]}' do
+        has 'key', ['value1', 'wrong_value2']
+      end
+    end
+  end
+  
+  def test_hash_with_array_of_hashes
+    assert_json '{"key":[{"inner_key1":"value1"},{"inner_key2":"value2"}]}' do
+      has 'key' do
+        has 'inner_key1', 'value1'
+        has 'inner_key2', 'value2'
+      end
+    end
+  end
+  def test_hash_with_array_of_hashes_crosscheck_inner_key
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":[{"inner_key1":"value1"},{"inner_key2":"value2"}]}' do
+        has 'key' do
+          has 'wrong_inner_key1', 'value1'
+        end
+      end
+    end
+  end
+  def test_hash_with_array_of_hashes_crosscheck_inner_value
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":[{"inner_key1":"value1"},{"inner_key2":"value2"}]}' do
+        has 'key' do
+          has 'inner_key1', 'wrong_value1'
+        end
+      end
+    end
+  end
+  
+  def test_array_with_two_hashes
+    assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do
+      has 'key1', 'value1'
+      has 'key2', 'value2'
+    end
+  end
+  def test_array_with_nested_hashes
+    assert_json '[{"key1":{"key2":"value2"}}]' do
+      has 'key1' do
+        has 'key2', 'value2'
+      end
+    end
+  end
+  def test_array_with_two_hashes_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do
+        has 'wrong_key1', 'value1'
+        has 'key2', 'value2'
+      end
+    end
+    assert_raises(MiniTest::Assertion) do
+      assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do
+        has 'key1', 'value1'
+        has 'key2', 'wrong_value2'
+      end
+    end
+  end
+  
+  def test_nested_hashes
+    assert_json '{"outer_key":{"key":{"inner_key":"value"}}}' do
+      has 'outer_key' do
+        has 'key' do
+          has 'inner_key', 'value'
+        end
+      end
+    end
+  end
+  def test_nested_hashes_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"outer_key":{"key":{"inner_key":"value"}}}' do
+        has 'wrong_outer_key'
+      end
+    end
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"outer_key":{"key":{"inner_key":"value"}}}' do
+        has 'outer_key' do
+          has 'key' do
+            has 'inner_key', 'wrong_value'
+          end
+        end
+      end
+    end
+  end
+  
+  def test_real_xws
+    assert_json '[{"contact_request":{"sender_id":"3","receiver_id":"2","id":1}}]' do
+      has 'contact_request' do
+        has 'sender_id', '3'
+        has 'receiver_id', '2'
+        has 'id', 1
+      end
+    end
+  
+    assert_json '[{"private_message":{"sender":{"display_name":"first last"},"receiver_id":"2","body":"body"}}]' do
+      has 'private_message' do
+        has 'sender' do
+          has 'display_name', 'first last'
+        end
+        has 'receiver_id', '2'
+        has 'body', 'body'
+      end
+    end
+  end
+  
+  def test_not_enough_hass_in_array
+    assert_raises(MiniTest::Assertion) do
+      assert_json '["one","two"]' do
+        has "one"
+        has "two"
+        has "three"
+      end
+    end
+  end
+  
+  def test_not_enough_hass_in_hash_array
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":[{"key1":"value1"}, {"key2":"value2"}]}' do
+        has 'key' do
+          has 'key1', 'value1'
+          has 'key2', 'value2'
+          has 'key3'
+        end
+      end
+    end
+  end
+
+end

data/test/assert_json_test.rb

@@ -0,0 +1,268 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class AssertJsonTest < Test::Unit::TestCase
+  include AssertJson
+
+  def test_string
+    assert_json '"key"' do |json|
+      json.element 'key'
+    end
+  end
+  def test_string_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '"key"' do |json|
+        json.element 'wrong_key'
+      end
+    end
+  end
+  def test_regular_expression_for_strings
+    assert_json '"string"' do |json|
+      json.element /tri/
+    end
+  end
+  def test_regular_expression_for_hash_values
+    assert_json '{"key":"value"}' do |json|
+      json.element 'key', /alu/
+    end
+  end
+  
+  def test_single_hash
+    assert_json '{"key":"value"}' do |json|
+      json.element 'key', 'value'
+    end
+  end
+  def test_single_hash_crosscheck_for_key
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":"value"}' do |json|
+        json.element 'wrong_key', 'value'
+      end
+    end
+  end
+  def test_single_hash_crosscheck_for_value
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":"value"}' do |json|
+        json.element 'key', 'wrong_value'
+      end
+    end
+  end
+  
+  def test_not_element
+    assert_json '{"key":"value"}' do |json|
+      json.element 'key', 'value'
+      json.not_element 'key_not_included'
+    end
+  end
+  def test_not_element_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":"value"}' do |json|
+        json.not_element 'key'
+      end
+    end
+  end
+  
+  def test_array
+    assert_json '["value1","value2","value3"]' do |json|
+      json.element 'value1'
+      json.element 'value2'
+      json.element 'value3'
+    end
+  end
+  def test_not_element_array
+    assert_json '["value1","value2"]' do |json|
+      json.element 'value1'
+      json.element 'value2'
+      json.not_element 'value3'
+    end
+  end
+  def test_array_crosscheck_order
+    assert_raises(MiniTest::Assertion) do
+      assert_json '["value1","value2","value3"]' do |json|
+        json.element 'value2'
+      end
+    end
+  end
+  def test_array_crosscheck_for_first_item
+    assert_raises(MiniTest::Assertion) do
+      assert_json '["value1","value2","value3"]' do |json|
+        json.element 'wrong_value1'
+      end
+    end
+  end
+  def test_array_crosscheck_for_second_item
+    assert_raises(MiniTest::Assertion) do
+      assert_json '["value1","value2","value3"]' do |json|
+        json.element 'value1'
+        json.element 'wrong_value2'
+      end
+    end
+  end
+  
+  def test_nested_arrays
+    assert_json '[[["deep","another_depp"],["second_deep"]]]' do |json|
+      json.element [["deep","another_depp"],["second_deep"]]
+    end
+  end
+  def test_nested_arrays_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '[[["deep","another_depp"],["second_deep"]]]' do |json|
+        json.element [["deep","wrong_another_depp"],["second_deep"]]
+      end
+    end
+    assert_raises(MiniTest::Assertion) do
+      assert_json '[[["deep","another_depp"],["second_deep"]]]' do |json|
+        json.element [["deep","another_depp"],["wrong_second_deep"]]
+      end
+    end
+  end
+  
+  def test_hash_with_value_array
+    assert_json '{"key":["value1","value2"]}' do |json|
+      json.element 'key', ['value1', 'value2']
+    end
+  end
+  def test_hash_with_value_array_crosscheck_wrong_key
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":["value1","value2"]}' do |json|
+        json.element 'wrong_key', ['value1', 'value2']
+      end
+    end
+  end
+  def test_hash_with_value_array_crosscheck_wrong_value1
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":["value1","value2"]}' do |json|
+        json.element 'key', ['wrong_value1', 'value2']
+      end
+    end
+  end
+  def test_hash_with_value_array_crosscheck_wrong_value2
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":["value1","value2"]}' do |json|
+        json.element 'key', ['value1', 'wrong_value2']
+      end
+    end
+  end
+
+  def test_hash_with_array_of_hashes
+    assert_json '{"key":[{"inner_key1":"value1"},{"inner_key2":"value2"}]}' do |json|
+      json.element 'key' do
+        json.element 'inner_key1', 'value1'
+        json.element 'inner_key2', 'value2'
+      end
+    end
+  end
+  def test_hash_with_array_of_hashes_crosscheck_inner_key
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":[{"inner_key1":"value1"},{"inner_key2":"value2"}]}' do |json|
+        json.element 'key' do
+          json.element 'wrong_inner_key1', 'value1'
+        end
+      end
+    end
+  end
+  def test_hash_with_array_of_hashes_crosscheck_inner_value
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":[{"inner_key1":"value1"},{"inner_key2":"value2"}]}' do |json|
+        json.element 'key' do
+          json.element 'inner_key1', 'wrong_value1'
+        end
+      end
+    end
+  end
+  
+  def test_array_with_two_hashes
+    assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do |json|
+      json.element 'key1', 'value1'
+      json.element 'key2', 'value2'
+    end
+  end
+  def test_array_with_nested_hashes
+    assert_json '[{"key1":{"key2":"value2"}}]' do |json|
+      json.element 'key1' do
+        json.element 'key2', 'value2'
+      end
+    end
+  end
+  def test_array_with_two_hashes_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do |json|
+        json.element 'wrong_key1', 'value1'
+        json.element 'key2', 'value2'
+      end
+    end
+    assert_raises(MiniTest::Assertion) do
+      assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do |json|
+        json.element 'key1', 'value1'
+        json.element 'key2', 'wrong_value2'
+      end
+    end
+  end
+  
+  def test_nested_hashes
+    assert_json '{"outer_key":{"key":{"inner_key":"value"}}}' do |json|
+      json.element 'outer_key' do
+        json.element 'key' do
+          json.element 'inner_key', 'value'
+        end
+      end
+    end
+  end
+  def test_nested_hashes_crosscheck
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"outer_key":{"key":{"inner_key":"value"}}}' do |json|
+        json.element 'wrong_outer_key'
+      end
+    end
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"outer_key":{"key":{"inner_key":"value"}}}' do |json|
+        json.element 'outer_key' do
+          json.element 'key' do
+            json.element 'inner_key', 'wrong_value'
+          end
+        end
+      end
+    end
+  end
+
+  def test_real_xws
+    assert_json '[{"contact_request":{"sender_id":"3","receiver_id":"2","id":1}}]' do |json|
+      json.element 'contact_request' do
+        json.element 'sender_id', '3'
+        json.element 'receiver_id', '2'
+        json.element 'id', 1
+      end
+    end
+
+    assert_json '[{"private_message":{"sender":{"display_name":"first last"},"receiver_id":"2","body":"body"}}]' do |json|
+      json.element 'private_message' do
+        json.element 'sender' do
+          json.element 'display_name', 'first last'
+        end
+        json.element 'receiver_id', '2'
+        json.element 'body', 'body'
+      end
+    end
+  end
+
+  def test_not_enough_elements_in_array
+    assert_raises(MiniTest::Assertion) do
+      assert_json '["one","two"]' do |json|
+        json.element "one"
+        json.element "two"
+        json.element "three"
+      end
+    end
+  end
+
+  def test_not_enough_elements_in_hash_array
+    assert_raises(MiniTest::Assertion) do
+      assert_json '{"key":[{"key1":"value1"}, {"key2":"value2"}]}' do |json|
+        json.element 'key' do
+          json.element 'key1', 'value1'
+          json.element 'key2', 'value2'
+          json.element 'key3'
+        end
+      end
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'
+
+$:.push File.expand_path("../../lib", __FILE__)
+require File.dirname(__FILE__) + '/../lib/assert_json.rb'

metadata

@@ -2,17 +2,16 @@
 name: assert_json
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - "Thorsten B\xC3\xB6ttger"
-- Andree Wille
 - Ralph von der Heyden
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-05-05 00:00:00 +02:00
+date: 2011-10-27 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,11 +45,20 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/assert_json.rb
-- MIT-LICENSE
-- Rakefile
+- .gitignore
+- .rvmrc
 - Gemfile
+- Gemfile.lock
+- MIT-LICENSE
 - README.md
+- Rakefile
+- assert_json.gemspec
+- lib/assert_json.rb
+- lib/assert_json/assert_json.rb
+- lib/assert_json/version.rb
+- test/assert_json_new_dsl_test.rb
+- test/assert_json_test.rb
+- test/test_helper.rb
 has_rdoc: true
 homepage: https://github.com/xing/assert_json
 licenses: []
@@ -79,5 +87,7 @@ rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A gem to test JSON strings.
-test_files: []
-
+test_files: 
+- test/assert_json_new_dsl_test.rb
+- test/assert_json_test.rb
+- test/test_helper.rb