assert_json 0.3.0 → 0.4.0

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 0.4.0
+
+ * add support for `size` (to test the size of arrays and hashes) (thanks to [@thomasjachmann](https://github.com/thomasjachmann), see [pull request 9](https://github.com/alto/assert_json/pull/9))
+
 ## 0.3.0
 
  * add support for `has_only` (to test that objects have the declared set of properties and nothing more) (thanks to [@derek-watson](https://github.com/derek-watson), see [issue 8](https://github.com/alto/assert_json/pull/8))

data/Gemfile

@@ -1,2 +1,3 @@
 source "http://rubygems.org"
 gemspec
+gem 'rubocop', require: false

data/HOWTO.md

@@ -0,0 +1,3 @@
+## How to run rubocop
+
+    rubocop -c .rubocop.yml

data/README.md

@@ -58,6 +58,14 @@ assert_json '[{"id":1, "key":"test", "name":"test"}, {"id":2, "key":"test", "nam
 end
 ```
 
+You can also check the size of arrays like this
+
+```ruby
+assert_json '["value1", "value2"]' do
+  size 2
+end
+```
+
 To test that objects have the declared set of properties and nothing more,
 include `has_only` at any level, like this
 

data/Rakefile

@@ -11,4 +11,4 @@ Rake::TestTask.new(:test) do |t|
 end
 
 desc 'Default: run unit tests.'
-task :default => :test
+task default: :test

data/assert_json.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
 require "assert_json/version"
 
 Gem::Specification.new do |s|
@@ -9,17 +9,18 @@ Gem::Specification.new do |s|
   s.description = "A gem to test JSON strings."
 
   s.authors = ["Thorsten Böttger"]
-  s.email = %q{boettger@mt7.de}
-  s.homepage = %q{https://github.com/alto/assert_json}
+  s.email = %w(boettger@mt7.de)
+  s.homepage = 'https://github.com/alto/assert_json'
   s.licenses = ["MIT"]
 
   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.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
   s.add_dependency 'activesupport'
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'maxitest'
+  s.add_development_dependency 'shoulda-context'
 end

data/lib/assert_json/assert_json.rb

@@ -1,12 +1,16 @@
+# nodoc
 module AssertJson
+  def assert_json(json_string)
+    return unless block_given?
 
-  def assert_json(json_string, &block)
-    if block_given?
-      @json = AssertJson::Json.new(json_string)
-      # json.instance_exec(json, &block)
-      yield @json
-      @json.test_for_unexpected_keys('root')
-    end
+    @json = AssertJson::Json.new(json_string)
+    # json.instance_exec(json, &block)
+    yield @json
+    @json.test_for_unexpected_keys('root')
+  end
+
+  def size(expected)
+    @json.size(expected)
   end
 
   def item(index, &block)
@@ -17,23 +21,31 @@ module AssertJson
     @json.has(*args, &block)
   end
 
-  def has_not(*args, &block)
+  def not?(*args, &block)
     @json.has_not(*args, &block)
   end
+  alias_method :has_not, :not?
 
-  def has_only
+  def only?
     @json.has_only
   end
+  alias_method :has_only, :only?
 
+  # nodoc
   class Json
-
     def initialize(json_string)
       @decoded_json = ActiveSupport::JSON.decode(json_string)
       @expected_keys = []
       @only = false
     end
 
-    def item(index, &block)
+    def size(expected)
+      raise_error("element #{@decoded_json.inspect} is not sizable") unless @decoded_json.respond_to?(:size)
+      return if @decoded_json.size == expected
+      raise_error("element #{@decoded_json.inspect} has #{@decoded_json.size} items, expected #{expected}")
+    end
+
+    def item(index)
       only_in_scope = @only
       expected_keys_in_scope = @expected_keys
       @expected_keys = []
@@ -49,7 +61,7 @@ module AssertJson
       end
     end
 
-    def element(*args, &block)
+    def element(*args)
       arg = args.shift
 
       token = case @decoded_json
@@ -65,7 +77,7 @@ module AssertJson
         raise_error("element #{arg} not found") unless token.keys.include?(arg)
         unless args.empty?
           second_arg = args.shift
-          gen_error = lambda {raise_error("element #{token[arg].inspect} does not match #{second_arg.inspect}")}
+          gen_error = -> { raise_error("element #{token[arg].inspect} does not match #{second_arg.inspect}") }
           case second_arg
           when Regexp
             gen_error.call if second_arg !~ token[arg].to_s
@@ -76,9 +88,7 @@ module AssertJson
           end
         end
       when Array
-        if !block_given? && token != arg
-          raise_error("element #{arg} not found")
-        end
+        raise_error("element #{arg} not found") if !block_given? && token != arg
       when String
         case arg
         when Regexp
@@ -94,30 +104,29 @@ module AssertJson
 
       @expected_keys.push arg
 
-      if block_given?
-        begin
-          only_in_scope = @only
-          expected_keys_in_scope = @expected_keys
-          @expected_keys = []
-          decoded_json_in_scope = @decoded_json
-          @decoded_json = case token
-                          when Hash
-                            token[arg]
-                          else
-                            token
-                          end
-          yield
-          test_for_unexpected_keys(arg)
-        ensure
-          @expected_keys = expected_keys_in_scope
-          @only = only_in_scope
-          @decoded_json = decoded_json_in_scope
-        end
+      return unless block_given?
+      begin
+        only_in_scope = @only
+        expected_keys_in_scope = @expected_keys
+        @expected_keys = []
+        decoded_json_in_scope = @decoded_json
+        @decoded_json = case token
+                        when Hash
+                          token[arg]
+                        else
+                          token
+                        end
+        yield
+        test_for_unexpected_keys(arg)
+      ensure
+        @expected_keys = expected_keys_in_scope
+        @only = only_in_scope
+        @decoded_json = decoded_json_in_scope
       end
     end
-    alias has element
+    alias_method :has, :element
 
-    def not_element(*args, &block)
+    def not_element(*args)
       arg = args.shift
       token = @decoded_json
       case token
@@ -127,33 +136,30 @@ module AssertJson
         raise_error("element #{arg} found, but not expected") if token.keys.include?(arg.to_s)
       end
     end
-    alias has_not not_element
+    alias_method :has_not, :not_element
 
     def only
       @only = true
     end
-    alias has_only only
+    alias_method :has_only, :only
 
     def test_for_unexpected_keys(name = 'root')
       return unless @only
+      return unless @decoded_json.is_a?(Hash)
 
-      if @decoded_json.is_a?(Hash)
-        unexpected_keys = @decoded_json.keys - @expected_keys
-        if unexpected_keys.count > 0
-          raise_error("element #{name} has unexpected keys: #{unexpected_keys.join(', ')}")
-        end
-      end
+      unexpected_keys = @decoded_json.keys - @expected_keys
+      return if unexpected_keys.count <= 0
+      raise_error("element #{name} has unexpected keys: #{unexpected_keys.join(', ')}")
     end
 
     private
 
-      def raise_error(message)
-        if Object.const_defined?(:MiniTest)
-          raise MiniTest::Assertion.new(message)
-        else
-          raise Test::Unit::AssertionFailedError.new(message)
-        end
+    def raise_error(message)
+      if Object.const_defined?(:MiniTest)
+        fail MiniTest::Assertion, message
+      else
+        fail Test::Unit::AssertionFailedError, message
       end
-
+    end
   end
 end

data/lib/assert_json/version.rb

@@ -1,3 +1,4 @@
+# nodoc
 module AssertJson
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/test/assert_json_has_only_test.rb

@@ -1,94 +1,130 @@
 require_relative './test_helper'
 
+# nodoc
 class AssertJsonHasNoUnexpectedKeysTest < Minitest::Test
   include AssertJson
 
-  def test_on_root_object
-    assert_json '{"keyA":"value","keyB":"value"}' do
-      has_only
-      has 'keyA'
-      has 'keyB'
-    end
-  end
-
-  def test_on_root_object_failure
-    err = assert_raises(MiniTest::Assertion) do
+  context "has_only" do
+    should "test_on_root_object" do
       assert_json '{"keyA":"value","keyB":"value"}' do
         has_only
-        has 'keyA', 'value'
+        has 'keyA'
+        has 'keyB'
       end
     end
-    assert_equal 'element root has unexpected keys: keyB', err.message
-  end
 
-  def test_on_root_object_with_sub_object
-    assert_json '{"keyA":{"subKeyA":"value","subKeyB":"value"},"keyB":"value"}' do
-      has_only
-      has 'keyA' do
-        has 'subKeyA'
-        has 'subKeyB'
+    should "test_on_root_object_failure" do
+      err = assert_raises(MiniTest::Assertion) do
+        assert_json '{"keyA":"value","keyB":"value"}' do
+          has_only
+          has 'keyA', 'value'
+        end
       end
-      has 'keyB'
+      assert_equal 'element root has unexpected keys: keyB', err.message
     end
-  end
 
-  def test_on_root_object_with_sub_object_failure
-    err = assert_raises(MiniTest::Assertion) do
+    should "test_on_root_object_with_sub_object" do
       assert_json '{"keyA":{"subKeyA":"value","subKeyB":"value"},"keyB":"value"}' do
         has_only
         has 'keyA' do
           has 'subKeyA'
           has 'subKeyB'
         end
+        has 'keyB'
       end
     end
-    assert_equal 'element root has unexpected keys: keyB', err.message
-  end
 
-  def test_on_sub_object
-    assert_json '{"keyA":{"subKeyA":"value","subKeyB":"value"},"keyB":"value"}' do
-      has 'keyA' do
-        has_only
-        has 'subKeyA'
-        has 'subKeyB'
+    should "test_on_root_object_with_sub_object_failure" do
+      err = assert_raises(MiniTest::Assertion) do
+        assert_json '{"keyA":{"subKeyA":"value","subKeyB":"value"},"keyB":"value"}' do
+          has_only
+          has 'keyA' do
+            has 'subKeyA'
+            has 'subKeyB'
+          end
+        end
       end
+      assert_equal 'element root has unexpected keys: keyB', err.message
     end
-  end
 
-  def test_on_sub_object_failure
-    err = assert_raises(MiniTest::Assertion) do
+    should "test_on_sub_object" do
       assert_json '{"keyA":{"subKeyA":"value","subKeyB":"value"},"keyB":"value"}' do
         has 'keyA' do
           has_only
           has 'subKeyA'
+          has 'subKeyB'
         end
       end
     end
-    assert_equal 'element keyA has unexpected keys: subKeyB', err.message
-  end
 
-  def test_on_root_array_of_objects
-    assert_json '[{"id":1, "key":"test", "name":"test"}, {"id":2, "key":"test", "name":"test"}, {"id":3, "key":"test", "name":"test"}]' do
-      has_only
-      item 0 do
-        has :id, 1
-        has :key, 'test'
-        has :name, 'test'
+    should "test_on_sub_object_failure" do
+      err = assert_raises(MiniTest::Assertion) do
+        assert_json '{"keyA":{"subKeyA":"value","subKeyB":"value"},"keyB":"value"}' do
+          has 'keyA' do
+            has_only
+            has 'subKeyA'
+          end
+        end
       end
+      assert_equal 'element keyA has unexpected keys: subKeyB', err.message
     end
-  end
 
-  def test_on_root_array_of_objects_failure
-    err = assert_raises(MiniTest::Assertion) do
-      assert_json '[{"id":1, "key":"test", "name":"test"}, {"id":2, "key":"test", "name":"test"}, {"id":3, "key":"test", "name":"test"}]' do
+    should "test_on_root_array_of_objects" do
+      json = <<JSON
+[
+  {
+    "id":1,
+    "key":"test",
+    "name":"test"
+  },{
+    "id":2,
+    "key":"test",
+    "name":"test"
+  },{
+    "id":3,
+    "key":"test",
+    "name":"test"
+  }
+]
+JSON
+      assert_json json do
         has_only
         item 0 do
           has :id, 1
           has :key, 'test'
+          has :name, 'test'
         end
       end
     end
-    assert_equal 'element 0 has unexpected keys: name', err.message
-  end
 
+    should "test_on_root_array_of_objects_failure" do
+      err = assert_raises(MiniTest::Assertion) do
+        json = <<JSON
+[
+  {
+    "id":1,
+    "key":"test",
+    "name":"test"
+  },{
+    "id":2,
+    "key":"test",
+    "name":"test"
+  },{
+    "id":3,
+    "key":"test",
+    "name":"test"
+  }
+]
+JSON
+        assert_json json do
+          has_only
+          item 0 do
+            has :id, 1
+            has :key, 'test'
+          end
+        end
+      end
+      assert_equal 'element 0 has unexpected keys: name', err.message
+    end
+  end
 end

data/test/assert_json_new_dsl_test.rb

@@ -1,477 +1,578 @@
 require 'test_helper'
 
+# nodoc
 class AssertJsonNewDslTest < Minitest::Test
   include AssertJson
 
-  def test_string
-    assert_json '"key"' do
-      has 'key'
-    end
-  end
-  def test_string_crosscheck
-    assert_raises(MiniTest::Assertion) do
+  context "strings" do
+    should "test_string" do
       assert_json '"key"' do
-        has 'wrong_key'
+        has '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/
+    should "test_string_crosscheck" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '"key"' do
+          has 'wrong_key'
+        end
+      end
     end
-  end
-
-  def test_single_hash
-    assert_json '{"key":"value"}' do
-      has 'key', 'value'
+    should "test_regular_expression_for_strings" do
+      assert_json '"string"' do
+        has(/tri/)
+      end
     end
-  end
-  def test_single_hash_with_outer_variable
-    @values = {'value' => 'value'}
-    assert_json '{"key":"value"}' do
-      has 'key', @values['value']
+    should "test_regular_expression_for_hash_values" do
+      assert_json '{"key":"value"}' do
+        has 'key', /alu/
+      end
     end
-  end
-  def test_single_hash_crosscheck_for_key
-    assert_raises(MiniTest::Assertion) do
+  end # strings
+
+  context "hashes" do
+    should "test_single_hash" do
       assert_json '{"key":"value"}' do
-        has 'wrong_key', 'value'
+        has 'key', 'value'
       end
     end
-  end
-  def test_single_hash_crosscheck_for_value
-    assert_raises(MiniTest::Assertion) do
+    should "test_single_hash_with_outer_variable" do
+      @values = { 'value' => 'value' }
       assert_json '{"key":"value"}' do
-        has 'key', 'wrong_value'
+        has 'key', @values['value']
       end
     end
-  end
-
-  def test_has_not
-    assert_json '{"key":"value"}' do
-      has 'key', 'value'
-      has_not 'key_not_included'
+    should "test_single_hash_crosscheck_for_key" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key":"value"}' do
+          has 'wrong_key', 'value'
+        end
+      end
     end
-  end
-  def test_has_not_crosscheck
-    assert_raises(MiniTest::Assertion) do
-      assert_json '{"key":"value"}' do
-        has_not 'key'
+    should "test_single_hash_crosscheck_for_value" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key":"value"}' do
+          has 'key', 'wrong_value'
+        end
       end
     end
-  end
 
-  def test_array
-    assert_json '["value1","value2","value3"]' do
-      has 'value1'
-      has 'value2'
-      has 'value3'
+    should "test_has_not" do
+      assert_json '{"key":"value"}' do
+        has 'key', 'value'
+        has_not 'key_not_included'
+      end
     end
-  end
-  def test_has_not_array
-    assert_json '["value1","value2"]' do
-      has 'value1'
-      has 'value2'
-      has_not 'value3'
+    should "test_has_not_crosscheck" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key":"value"}' do
+          has_not 'key'
+        end
+      end
     end
-  end
-  def test_array_crosscheck_order
-    assert_raises(MiniTest::Assertion) do
+  end # hashes
+
+  context "arrays" do
+    should "test_array" do
       assert_json '["value1","value2","value3"]' do
+        has 'value1'
         has 'value2'
+        has 'value3'
       end
     end
-  end
-  def test_array_crosscheck_for_first_item
-    assert_raises(MiniTest::Assertion) do
-      assert_json '["value1","value2","value3"]' do
-        has 'wrong_value1'
+    should "test_has_not_array" do
+      assert_json '["value1","value2"]' do
+        has 'value1'
+        has 'value2'
+        has_not 'value3'
       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'
+    should "test_array_crosscheck_order" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '["value1","value2","value3"]' do
+          has 'value2'
+        end
       end
     end
-  end
-
-  def test_nested_arrays
-    assert_json '[[["deep","another_depp"],["second_deep"]]]' do
-      has [["deep","another_depp"],["second_deep"]]
+    should "test_array_crosscheck_for_first_item" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '["value1","value2","value3"]' do
+          has 'wrong_value1'
+        end
+      end
     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"]]
+    should "test_array_crosscheck_for_second_item" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '["value1","value2","value3"]' do
+          has 'value1'
+          has 'wrong_value2'
+        end
       end
     end
-    assert_raises(MiniTest::Assertion) do
+
+    should "test_nested_arrays" do
       assert_json '[[["deep","another_depp"],["second_deep"]]]' do
-        has [["deep","another_depp"],["wrong_second_deep"]]
+        has [%w(deep another_depp), %w(second_deep)]
+      end
+    end
+    should "test_nested_arrays_crosscheck" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '[[["deep","another_depp"],["second_deep"]]]' do
+          has [%w(deep wrong_another_depp), %w(second_deep)]
+        end
+      end
+      assert_raises(MiniTest::Assertion) do
+        assert_json '[[["deep","another_depp"],["second_deep"]]]' do
+          has [%w(deep another_depp), %w(wrong_second_deep)]
+        end
       end
     end
-  end
 
-  def test_itemised_nested_array
-    json = '[["deep","another_depp"],["second_deep"]]'
-    assert_json json do
-      item 0 do
-        item 0 do
-          has 'deep'
+    should "test_array_size" do
+      assert_json '["value1","value2"]' do
+        size 2
+      end
+    end
+
+    should "test_array_size_error" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '["single value"]' do
+          size 2
         end
+      end
+    end
+
+    should "test_nested_array_size" do
+      assert_json '["value1",["value2.1","value2.2","value3.3"]]' do
+        size 2
         item 1 do
-          has 'another_depp'
+          size 3
         end
       end
-      item 1 do
-        has 'second_deep'
+    end
+
+    should "test_itemised_nested_array" do
+      json = '[["deep","another_depp"],["second_deep"]]'
+      assert_json json do
+        item 0 do
+          item 0 do
+            has 'deep'
+          end
+          item 1 do
+            has 'another_depp'
+          end
+        end
+        item 1 do
+          has 'second_deep'
+        end
       end
     end
-  end
-  def test_itemised_nested_array_crosscheck
-    json = '[["deep","another_depp"],["second_deep"]]'
-    assert_json json do
-      item 0 do
+    should "test_itemised_nested_array_crosscheck" do
+      json = '[["deep","another_depp"],["second_deep"]]'
+      assert_json json do
         item 0 do
-          has 'deep'
+          item 0 do
+            has 'deep'
+          end
+          item 1 do
+            assert_raises(MiniTest::Assertion) do
+              has 'wrong_item_value'
+            end
+          end
         end
         item 1 do
           assert_raises(MiniTest::Assertion) do
-            has 'wrong_item_value'
+            has 'unknown_item_value'
           end
         end
       end
-      item 1 do
-        assert_raises(MiniTest::Assertion) do
-          has 'unknown_item_value'
-        end
-      end
     end
-  end
+  end # arrays
 
-  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
+  context "hashes with arrays" do
+    should "test_hash_with_value_array" do
       assert_json '{"key":["value1","value2"]}' do
-        has 'wrong_key', ['value1', 'value2']
+        has 'key', %w(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']
+    should "test_hash_with_value_array_crosscheck_wrong_key" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key":["value1","value2"]}' do
+          has 'wrong_key', %w(value1 value2)
+        end
       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']
+    should "test_hash_with_value_array_crosscheck_wrong_value1" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key":["value1","value2"]}' do
+          has 'key', %w(wrong_value1 value2)
+        end
       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'
+    should "test_hash_with_value_array_crosscheck_wrong_value2" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key":["value1","value2"]}' do
+          has 'key', %w(value1 wrong_value2)
+        end
       end
     end
-  end
-  def test_hash_with_array_of_hashes_crosscheck_inner_key
-    assert_raises(MiniTest::Assertion) do
+
+    should "test_hash_with_array_of_hashes" do
       assert_json '{"key":[{"inner_key1":"value1"},{"inner_key2":"value2"}]}' do
         has 'key' do
-          has 'wrong_inner_key1', 'value1'
+          has 'inner_key1', 'value1'
+          has 'inner_key2', 'value2'
         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'
+    should "test_hash_with_array_of_hashes_crosscheck_inner_key" do
+      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
-  end
-
-
-  def test_array_with_multi_item_hashes
-    assert_json '[{"id":1, "key":"test", "name":"test"}, {"id":2, "key":"test", "name":"test"}, {"id":3, "key":"test", "name":"test"}]' do
-      item 0 do
-        has 'id', 1
-        has 'key', 'test'
-        has 'name', 'test'
-      end
-      item 2 do
-        has 'id', 3
+    should "test_hash_with_array_of_hashes_crosscheck_inner_value" do
+      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
-  end
-  def test_array_with_multi_item_hashes_crosscheck
-    assert_raises(MiniTest::Assertion) do
-      assert_json '[{"id":1, "key":"test", "name":"test"}, {"id":2, "key":"test", "name":"test"}, {"id":3, "key":"test", "name":"test"}]' do
+  end # hashes with arrays
+
+  context "arrays with hashes" do
+    should "test_array_with_multi_item_hashes" do
+      json = <<JSON
+[
+  {
+    "id":1,
+    "key":"test",
+    "name":"test"
+  },{
+    "id":2,
+    "key":"test",
+    "name":"test"
+  },{
+    "id":3,
+    "key":"test",
+    "name":"test"
+  }
+]
+JSON
+      assert_json json do
         item 0 do
           has 'id', 1
           has 'key', 'test'
           has 'name', 'test'
         end
         item 2 do
-          has 'id', 2
+          has 'id', 3
         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'
+    should "test_array_with_multi_item_hashes_crosscheck" do
+      assert_raises(MiniTest::Assertion) do
+        json = <<JSON
+[
+  {
+    "id":1,
+    "key":"test",
+    "name":"test"
+  },{
+    "id":2,
+    "key":"test",
+    "name":"test"
+  },{
+    "id":3,
+    "key":"test",
+    "name":"test"
+  }
+]
+JSON
+        assert_json json do
+          item 0 do
+            has 'id', 1
+            has 'key', 'test'
+            has 'name', 'test'
+          end
+          item 2 do
+            has 'id', 2
+          end
+        end
       end
     end
-  end
-  def test_array_with_two_hashes_crosscheck
-    assert_raises(MiniTest::Assertion) do
+
+    should "test_array_with_two_hashes" do
       assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do
-        has 'wrong_key1', 'value1'
+        has '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'
+    should "test_array_with_nested_hashes" do
+      assert_json '[{"key1":{"key2":"value2"}}]' do
+        has 'key1' do
+          has 'key2', 'value2'
+        end
       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'
+    should "test_array_with_two_hashes_crosscheck" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do
+          has 'wrong_key1', 'value1'
+          has 'key2', 'value2'
         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'
+      assert_raises(MiniTest::Assertion) do
+        assert_json '[{"key1":"value1"}, {"key2":"value2"}]' do
+          has 'key1', 'value1'
+          has 'key2', 'wrong_value2'
+        end
       end
     end
-    assert_raises(MiniTest::Assertion) do
+  end # arrays with hashes
+
+  context "nested hashes" do
+    should "test_nested_hashes" do
       assert_json '{"outer_key":{"key":{"inner_key":"value"}}}' do
         has 'outer_key' do
           has 'key' do
-            has 'inner_key', 'wrong_value'
+            has 'inner_key', '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
+    should "test_nested_hashes_crosscheck" do
+      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
-
-    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 # nested hashes
+
+  context "real life examples" do
+    should "test_complex_example" do
+      json = <<JSON
+{
+  "count":2,
+  "total_count":3,
+  "results":[
+    {
+      "id":14,
+      "tags":[
+        "tag1",
+        "tag2"
+      ],
+      "created_at":"2014-10-14T00:50:39Z",
+      "updated_at":"2014-10-14T00:51:39Z"
+    },{
+      "id":15,
+      "tags":[
+        "tag3",
+        "tag4"
+      ],
+      "created_at":"2014-10-15T00:50:39Z",
+      "updated_at":"2014-10-15T00:51:39Z"
+    }
+  ]
+}
+JSON
+
+      assert_json json do
+        has 'count', 2
+        has 'total_count', 3
+        has 'results' do
+          item 0 do
+            has 'id', 14
+            has 'tags' do
+              item 0 do
+                has 'tag1'
+              end
+              item 1 do
+                has 'tag2'
+              end
+            end
+            has 'created_at', '2014-10-14T00:50:39Z'
+            has 'updated_at', '2014-10-14T00:51:39Z'
+          end
         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"
+    should "test_real_xws" do
+      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
-    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'
+      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
-  end
+  end # real life examples
 
-  def test_boolean
-    assert_json '{"key": true}' do
-      has 'key', true
-    end
-    assert_json '{"key": false}' do
-      has 'key', false
+  context "not enough elements" do
+    should "test_not_enough_hass_in_array" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '["one","two"]' do
+          has "one"
+          has "two"
+          has "three"
+        end
+      end
     end
-  end
 
-  def test_boolean_crosscheck
-    assert_raises(MiniTest::Assertion) do
-      assert_json '{"key": false}' do
-        has 'key', true
+    should "test_not_enough_hass_in_hash_array" do
+      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
-    assert_raises(MiniTest::Assertion) do
+  end # not enough elements
+
+  context "boolean" do
+    should "test_boolean" do
       assert_json '{"key": true}' do
+        has 'key', true
+      end
+      assert_json '{"key": false}' do
         has 'key', false
       end
     end
-  end
-
-  def test_null
-    assert_json '{"key": null}' do
-      has 'key', nil
-    end
-  end
 
-  def test_not_null
-    assert_raises(MiniTest::Assertion) do
-      assert_json '{"key": 1}' do
-        has 'key', nil
+    should "test_boolean_crosscheck" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key": false}' do
+          has 'key', true
+        end
+      end
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key": true}' do
+          has 'key', false
+        end
       end
     end
-  end
+  end # boolean
 
-  def test_null_crosscheck
-    assert_raises(MiniTest::Assertion) do
+  context "null" do
+    should "test_null" do
       assert_json '{"key": null}' do
-        has_not 'key'
+        has 'key', nil
       end
     end
-  end
 
-  def test_symbol_as_a_value
-    assert_json '{"key": "text"}' do
-      has :key, :text
-    end
-    assert_raises(MiniTest::Assertion) do
-      assert_json '{"key": "badtext"}' do
-        has :key, :text
+    should "test_not_null" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key": 1}' do
+          has 'key', nil
+        end
       end
     end
-  end
 
-  def test_symbol_as_a_key
-    assert_json '{"sym": true, "text": "1"}' do
-      has :sym, true
-      has :text, /\d+/
-      has_not :bad_sym
-    end
-    assert_json '{"sym": false, "text": "2", "topkey": {"subkey": "value1"}}' do
-      has :sym, false
-      has :text, /\d+/
-      has_not :bad_sym
-      has :topkey do
-        has :subkey, :value1
+    should "test_null_crosscheck" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key": null}' do
+          has_not 'key'
+        end
       end
     end
-  end
+  end # null
 
-  def test_symbol_as_string_value
-    assert_json '{"topkey": {"subkey": "value1"}}' do
-      has :topkey do
-        has :subkey do
-          has :value1
+  context "symbols" do
+    should "test_symbol_as_a_value" do
+      assert_json '{"key": "text"}' do
+        has :key, :text
+      end
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"key": "badtext"}' do
+          has :key, :text
         end
       end
     end
-  end
-
 
-  def test_symbol_as_a_key_crossheck
-    assert_raises(MiniTest::Assertion) do
-      assert_json '{"text": "1"}' do
-        has :sym, true  #this should fail
+    should "test_symbol_as_a_key" do
+      assert_json '{"sym": true, "text": "1"}' do
+        has :sym, true
         has :text, /\d+/
         has_not :bad_sym
       end
-    end
-
-    assert_raises(MiniTest::Assertion) do
-      assert_json '{"sym": false, "text": "abc"}' do
+      assert_json '{"sym": false, "text": "2", "topkey": {"subkey": "value1"}}' do
         has :sym, false
-        has :text, /\d+/   #this should fail
+        has :text, /\d+/
         has_not :bad_sym
+        has :topkey do
+          has :subkey, :value1
+        end
       end
     end
 
-    assert_raises(MiniTest::Assertion) do
-      assert_json '{"sym": false}' do
-        has_not :sym
+    should "test_symbol_as_string_value" do
+      assert_json '{"topkey": {"subkey": "value1"}}' do
+        has :topkey do
+          has :subkey do
+            has :value1
+          end
+        end
       end
     end
-  end
 
-  def test_regex_with_number
-    assert_json '{"number": 1}' do
-      has :number, /^\d+$/
-    end
-  end
+    should "test_symbol_as_a_key_crossheck" do
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"text": "1"}' do
+          has :sym, true  # this should fail
+          has :text, /\d+/
+          has_not :bad_sym
+        end
+      end
 
-  # for issue #/
-  def test_complex_example
-    json = '{"count":2,"total_count":3,"results":[{"id":14,"tags":["tag1","tag2"],"created_at":"2014-10-14T00:50:39Z","updated_at":"2014-10-14T00:51:39Z"},{"id":15,"tags":["tag3","tag4"],"created_at":"2014-10-15T00:50:39Z","updated_at":"2014-10-15T00:51:39Z"}]}'
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"sym": false, "text": "abc"}' do
+          has :sym, false
+          has :text, /\d+/   # this should fail
+          has_not :bad_sym
+        end
+      end
 
-    assert_json json do
-      has 'count', 2
-      has 'total_count', 3
-      has 'results' do
-        item 0 do
-          has 'id', 14
-          has 'tags' do
-            item 0 do
-              has 'tag1'
-            end
-            item 1 do
-              has 'tag2'
-            end
-          end
-          has 'created_at', '2014-10-14T00:50:39Z'
-          has 'updated_at', '2014-10-14T00:51:39Z'
+      assert_raises(MiniTest::Assertion) do
+        assert_json '{"sym": false}' do
+          has_not :sym
         end
       end
     end
-  end
+  end # symbols
 
+  context "regular expressions for numbers" do
+    should "test_regex_with_number" do
+      assert_json '{"number": 1}' do
+        has :number, /^\d+$/
+      end
+    end
+  end
 end