jsonpath 0.9.3 → 1.1.5

data/test/test_jsonpath.rb

@@ -48,13 +48,18 @@ class TestJsonpath < MiniTest::Unit::TestCase
   end
 
   def test_recognize_array_splices
-    assert_equal [@object['store']['book'][0], @object['store']['book'][1]], JsonPath.new('$..book[0:1:1]').on(@object)
+    assert_equal [@object['store']['book'][0]], JsonPath.new('$..book[0:1:1]').on(@object)
+    assert_equal [@object['store']['book'][0], @object['store']['book'][1]], JsonPath.new('$..book[0:2:1]').on(@object)
     assert_equal [@object['store']['book'][1], @object['store']['book'][3], @object['store']['book'][5]], JsonPath.new('$..book[1::2]').on(@object)
     assert_equal [@object['store']['book'][0], @object['store']['book'][2], @object['store']['book'][4], @object['store']['book'][6]], JsonPath.new('$..book[::2]').on(@object)
     assert_equal [@object['store']['book'][0], @object['store']['book'][2]], JsonPath.new('$..book[:-5:2]').on(@object)
     assert_equal [@object['store']['book'][5], @object['store']['book'][6]], JsonPath.new('$..book[5::]').on(@object)
   end
 
+  def test_slice_array_with_exclusive_end_correctly
+    assert_equal [@object['store']['book'][0], @object['store']['book'][1]], JsonPath.new('$..book[:2]').on(@object)
+  end
+
   def test_recognize_array_comma
     assert_equal [@object['store']['book'][0], @object['store']['book'][1]], JsonPath.new('$..book[0,1]').on(@object)
     assert_equal [@object['store']['book'][2], @object['store']['book'][6]], JsonPath.new('$..book[2,-1::]').on(@object)
@@ -67,16 +72,63 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal [@object['store']['book'][3]], JsonPath.new("$..book[?(@['price'] > 20)]").on(@object)
   end
 
+  def test_not_equals_operator
+    expected =
+      [
+        @object['store']['book'][0],
+        @object['store']['book'][4],
+        @object['store']['book'][5],
+        @object['store']['book'][6]
+      ]
+    assert_equal(expected, JsonPath.new("$..book[?(@['category'] != 'fiction')]").on(@object))
+    assert_equal(expected, JsonPath.new("$..book[?(@['category']!=fiction)]").on(@object))
+    assert_equal(expected, JsonPath.new("$..book[?(@.category!=fiction)]").on(@object))
+    assert_equal(expected, JsonPath.new("$..book[?(@.category != 'fiction')]").on(@object))
+  end
+
   def test_or_operator
     assert_equal [@object['store']['book'][1], @object['store']['book'][3]], JsonPath.new("$..book[?(@['price'] == 13 || @['price'] == 23)]").on(@object)
+    result = ["Sayings of the Century", "Sword of Honour", "Moby Dick", "The Lord of the Rings"]
+    assert_equal result, JsonPath.new("$..book[?(@.price==13 || @.price==9 || @.price==23)].title").on(@object)
+    assert_equal result, JsonPath.new("$..book[?(@.price==9 || @.price==23 || @.price==13)].title").on(@object)
+    assert_equal result, JsonPath.new("$..book[?(@.price==23 || @.price==13 || @.price==9)].title").on(@object)
+  end
+
+  def test_or_operator_with_not_equals
+    # Should be the same regardless of key style ( @.key vs @['key'] )
+    result = ['Nigel Rees', 'Evelyn Waugh', 'Herman Melville', 'J. R. R. Tolkien', 'Lukyanenko']
+    assert_equal result, JsonPath.new("$..book[?(@['title']=='Osennie Vizity' || @['author']!='Lukyanenko')].author").on(@object)
+    assert_equal result, JsonPath.new("$..book[?(@.title=='Osennie Vizity' || @.author != Lukyanenko )].author").on(@object)
+    assert_equal result, JsonPath.new("$..book[?(@.title=='Osennie Vizity' || @.author!=Lukyanenko )].author").on(@object)
   end
 
   def test_and_operator
     assert_equal [], JsonPath.new("$..book[?(@['price'] == 13 && @['price'] == 23)]").on(@object)
+    assert_equal [], JsonPath.new("$..book[?(@.price>=13 && @.category==fiction && @.title==no_match)]").on(@object)
+    assert_equal [], JsonPath.new("$..book[?(@.title==no_match && @.category==fiction && @.price==13)]").on(@object)
+    assert_equal [], JsonPath.new("$..book[?(@.price==13 && @.title==no_match && @.category==fiction)]").on(@object)
+    assert_equal [], JsonPath.new("$..book[?(@.price==13 && @.bad_key_name==true && @.category==fiction)]").on(@object)
+
+    expected = [@object['store']['book'][1]]
+    assert_equal expected, JsonPath.new("$..book[?(@['price'] < 23 && @['price'] > 9)]").on(@object)
+    assert_equal expected, JsonPath.new("$..book[?(@.price < 23 && @.price > 9)]").on(@object)
+
+    expected = ['Sword of Honour', 'The Lord of the Rings']
+    assert_equal expected, JsonPath.new("$..book[?(@.price>=13 && @.category==fiction)].title").on(@object)
+    assert_equal ['The Lord of the Rings'], JsonPath.new("$..book[?(@.category==fiction && @.isbn && @.price>9)].title").on(@object)
+    assert_equal ['Sayings of the Century'], JsonPath.new("$..book[?(@['price'] == 9 && @.author=='Nigel Rees')].title").on(@object)
+    assert_equal ['Sayings of the Century'], JsonPath.new("$..book[?(@['price'] == 9 && @.tags..asdf)].title").on(@object)
+  end
+
+  def test_and_operator_with_not_equals
+    expected = ['Nigel Rees']
+    assert_equal expected, JsonPath.new("$..book[?(@['price']==9 && @['category']!=fiction)].author").on(@object)
+    assert_equal expected, JsonPath.new("$..book[?(@.price==9 && @.category!=fiction)].author").on(@object)
   end
 
-  def test_and_operator_with_more_results
-    assert_equal [@object['store']['book'][1]], JsonPath.new("$..book[?(@['price'] < 23 && @['price'] > 9)]").on(@object)
+  def test_nested_grouping
+    path = "$..book[?((@['price'] == 19 && @['author'] == 'Herman Melville') || @['price'] == 23)]"
+    assert_equal [@object['store']['book'][3]], JsonPath.new(path).on(@object)
   end
 
   def test_eval_with_floating_point_and_and
@@ -103,6 +155,87 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal [@object['store']['bicycle']['2seater']], JsonPath.new('$.store.bicycle.2seater').on(@object)
   end
 
+  def test_recognized_dot_notation_in_filters
+    assert_equal [@object['store']['book'][2], @object['store']['book'][3]], JsonPath.new('$..book[?(@.isbn)]').on(@object)
+  end
+
+  def test_works_on_non_hash
+    klass = Struct.new(:a, :b)
+    object = klass.new('some', 'value')
+
+    assert_equal ['value'], JsonPath.new('$.b').on(object)
+  end
+
+  def test_works_on_object
+    klass = Class.new{
+      attr_reader :b
+      def initialize(b)
+        @b = b
+      end
+    }
+    object = klass.new("value")
+
+    assert_equal ["value"], JsonPath.new('$.b').on(object)
+  end
+
+  def test_works_on_object_can_be_disabled
+    klass = Class.new{
+      attr_reader :b
+      def initialize(b)
+        @b = b
+      end
+    }
+    object = klass.new("value")
+
+    assert_equal [], JsonPath.new('$.b', allow_send: false).on(object)
+  end
+
+  def test_works_on_diggable
+    klass = Class.new{
+      attr_reader :h
+      def initialize(h)
+        @h = h
+      end
+      def dig(*keys)
+        @h.dig(*keys)
+      end
+    }
+
+    object = klass.new('a' => 'some', 'b' => 'value')
+    assert_equal ['value'], JsonPath.new('$.b').on(object)
+
+    object = {
+      "foo" => klass.new('a' => 'some', 'b' => 'value')
+    }
+    assert_equal ['value'], JsonPath.new('$.foo.b').on(object)
+  end
+
+  def test_works_on_non_hash_with_filters
+    klass = Struct.new(:a, :b)
+    first_object = klass.new('some', 'value')
+    second_object = klass.new('next', 'other value')
+
+    assert_equal ['other value'], JsonPath.new('$[?(@.a == "next")].b').on([first_object, second_object])
+  end
+
+  def test_works_on_hash_with_summary
+    object = {
+      "foo" => [{
+        "a" => "some",
+        "b" => "value"
+      }]
+    }
+    assert_equal [{ "b" => "value" }], JsonPath.new("$.foo[*](b)").on(object)
+  end
+
+  def test_works_on_non_hash_with_summary
+    klass = Struct.new(:a, :b)
+    object = {
+      "foo" => [klass.new("some", "value")]
+    }
+    assert_equal [{ "b" => "value" }], JsonPath.new("$.foo[*](b)").on(object)
+  end
+
   def test_recognize_array_with_evald_index
     assert_equal [@object['store']['book'][2]], JsonPath.new('$..book[(@.length-5)]').on(@object)
   end
@@ -112,7 +245,7 @@ class TestJsonpath < MiniTest::Unit::TestCase
   end
 
   def test_counting
-    assert_equal 57, JsonPath.new('$..*').on(@object).to_a.size
+    assert_equal 59, JsonPath.new('$..*').on(@object).to_a.size
   end
 
   def test_space_in_path
@@ -173,6 +306,83 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal({ 'you' => nil }, h)
   end
 
+  def test_delete_2
+    json = { 'store' => {
+      'book' => [
+        { 'category' => 'reference',
+          'author' => 'Nigel Rees',
+          'title' => 'Sayings of the Century',
+          'price' => 9,
+          'tags' => %w[asdf asdf2] },
+        { 'category' => 'fiction',
+          'author' => 'Evelyn Waugh',
+          'title' => 'Sword of Honour',
+          'price' => 13 },
+        { 'category' => 'fiction',
+          'author' => 'Aasdf',
+          'title' => 'Aaasdf2',
+          'price' => 1 }
+      ]
+    } }
+    json_deleted = { 'store' => {
+      'book' => [
+        { 'category' => 'fiction',
+          'author' => 'Evelyn Waugh',
+          'title' => 'Sword of Honour',
+          'price' => 13 },
+        { 'category' => 'fiction',
+          'author' => 'Aasdf',
+          'title' => 'Aaasdf2',
+          'price' => 1 }
+      ]
+    } }
+    assert_equal(json_deleted, JsonPath.for(json).delete("$..store.book[?(@.category == 'reference')]").obj)
+  end
+
+  def test_delete_3
+    json = { 'store' => {
+      'book' => [
+        { 'category' => 'reference',
+          'author' => 'Nigel Rees',
+          'title' => 'Sayings of the Century',
+          'price' => 9,
+          'tags' => %w[asdf asdf2],
+          'this' => {
+            'delete_me' => [
+              'no' => 'do not'
+            ]
+          } },
+        { 'category' => 'fiction',
+          'author' => 'Evelyn Waugh',
+          'title' => 'Sword of Honour',
+          'price' => 13 },
+        { 'category' => 'fiction',
+          'author' => 'Aasdf',
+          'title' => 'Aaasdf2',
+          'price' => 1 }
+      ]
+    } }
+    json_deleted = { 'store' => {
+      'book' => [
+        { 'category' => 'reference',
+          'author' => 'Nigel Rees',
+          'title' => 'Sayings of the Century',
+          'price' => 9,
+          'tags' => %w[asdf asdf2],
+          'this' => {} },
+        { 'category' => 'fiction',
+          'author' => 'Evelyn Waugh',
+          'title' => 'Sword of Honour',
+          'price' => 13 },
+        { 'category' => 'fiction',
+          'author' => 'Aasdf',
+          'title' => 'Aaasdf2',
+          'price' => 1 }
+      ]
+    } }
+    assert_equal(json_deleted, JsonPath.for(json).delete('$..store.book..delete_me').obj)
+  end
+
   def test_delete_for_array
     before = JsonPath.on(@object, '$..store.book[1]')
     JsonPath.for(@object).delete!('$..store.book[0]')
@@ -265,6 +475,16 @@ class TestJsonpath < MiniTest::Unit::TestCase
                  JsonPath.new('$.store._links').on(@object)
   end
 
+  def test_support_for_umlauts_in_member_names
+    assert_equal [@object['store']['Übermorgen']],
+                 JsonPath.new('$.store.Übermorgen').on(@object)
+  end
+
+  def test_support_for_spaces_in_member_name
+    assert_equal [@object['store']['Title Case']],
+                 JsonPath.new('$.store.Title Case').on(@object)
+  end
+
   def test_dig_return_string
     assert_equal ['asdf'], JsonPath.new("$.store.book..tags[?(@ == 'asdf')]").on(@object)
     assert_equal [], JsonPath.new("$.store.book..tags[?(@ == 'not_asdf')]").on(@object)
@@ -396,18 +616,65 @@ class TestJsonpath < MiniTest::Unit::TestCase
         'name' => 'testname2'
       }]
     }
-    assert_equal [{ 'isTrue' => true, 'name' => 'testname1' }], JsonPath.new('$.data[?(@.isTrue)]').on(data)
+
+    # These queries should be equivalent
+    expected = [{ 'isTrue' => true, 'name' => 'testname1' }]
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue)]').on(data)
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue==true)]').on(data)
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue == true)]').on(data)
+
+    # These queries should be equivalent
+    expected = [{ 'isTrue' => false, 'name' => 'testname2' }]
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue != true)]').on(data)
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue!=true)]').on(data)
+    assert_equal expected, JsonPath.new('$.data[?(@.isTrue==false)]').on(data)
+  end
+
+  def test_and_operator_with_boolean_parameter_value
+    data = {
+      'data' => [{
+        'hasProperty1' => true,
+        'hasProperty2' => false,
+        'name' => 'testname1'
+      }, {
+        'hasProperty1' => false,
+        'hasProperty2' => true,
+        'name' => 'testname2'
+      }, {
+        'hasProperty1' => true,
+        'hasProperty2' => true,
+        'name' => 'testname3'
+      }]
+    }
+    assert_equal ['testname3'], JsonPath.new('$.data[?(@.hasProperty1 && @.hasProperty2)].name').on(data)
+  end
+
+  def test_regex_simple
+    assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@ =~ /asdf/)]').on(@object)
+    assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@=~/asdf/)]').on(@object)
+  end
+
+  def test_regex_simple_miss
+    assert_equal [], JsonPath.new('$.store.book..tags[?(@ =~ /wut/)]').on(@object)
+  end
+
+  def test_regex_r
+    assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@ =~ %r{asdf})]').on(@object)
   end
 
-  def test_regex
-    assert_equal [], JsonPath.new('$..book[?(@.author =~ /herman/)]').on(@object)
+  def test_regex_flags
     assert_equal [
       @object['store']['book'][2],
       @object['store']['book'][4],
       @object['store']['book'][5],
       @object['store']['book'][6]
     ], JsonPath.new('$..book[?(@.author =~ /herman|lukyanenko/i)]').on(@object)
-    assert_equal %w[asdf asdf2], JsonPath.new('$.store.book..tags[?(@ =~ /asdf/)]').on(@object)
+  end
+
+  def test_regex_error
+    assert_raises ArgumentError do
+      JsonPath.new('$.store.book..tags[?(@ =~ asdf)]').on(@object)
+    end
   end
 
   def test_regression_1
@@ -508,6 +775,68 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal 'C09C5GYHF', JsonPath.on(json, "$..channels[?(@.is_archived == 'false')].id")[0]
   end
 
+  def test_quote
+    json = {
+      channels: [
+        {
+          name: "King's Speech"
+        }
+      ]
+    }.to_json
+
+    assert_equal [{ 'name' => "King\'s Speech" }], JsonPath.on(json, "$..channels[?(@.name == 'King\'s Speech')]")
+  end
+
+  def test_curly_brackets
+    data = {
+      '{data}' => 'data'
+    }
+    assert_equal ['data'], JsonPath.new('$.{data}').on(data)
+  end
+
+  def test_symbolize
+    data = '
+    {
+      "store": {
+        "bicycle": {
+          "price": 19.95,
+          "color": "red"
+        },
+        "book": [
+          {
+            "price": 8.95,
+            "category": "reference",
+            "title": "Sayings of the Century",
+            "author": "Nigel Rees"
+          },
+          {
+            "price": 12.99,
+            "category": "fiction",
+            "title": "Sword of Honour",
+            "author": "Evelyn Waugh"
+          },
+          {
+            "price": 8.99,
+            "category": "fiction",
+            "isbn": "0-553-21311-3",
+            "title": "Moby Dick",
+            "author": "Herman Melville",
+            "color": "blue"
+          },
+          {
+            "price": 22.99,
+            "category": "fiction",
+            "isbn": "0-395-19395-8",
+            "title": "The Lord of the Rings",
+            "author": "Tolkien"
+          }
+        ]
+      }
+    }
+    '
+    assert_equal [{ price: 8.95, category: 'reference', title: 'Sayings of the Century', author: 'Nigel Rees' }, { price: 8.99, category: 'fiction', isbn: '0-553-21311-3', title: 'Moby Dick', author: 'Herman Melville', color: 'blue' }], JsonPath.new('$..book[::2]').on(data, symbolize_keys: true)
+  end
+
   def test_changed
     json =
       {
@@ -562,6 +891,33 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal [true], JsonPath.on(json, broken_path)
   end
 
+  def test_complex_nested_grouping
+    path = "$..book[?((@['author'] == 'Evelyn Waugh' || @['author'] == 'Herman Melville') && (@['price'] == 33 || @['price'] == 9))]"
+    assert_equal [@object['store']['book'][2]], JsonPath.new(path).on(@object)
+  end
+  
+  def test_nested_with_unknown_key
+    path = "$..[?(@.price == 9 || @.price == 33)].title"
+    assert_equal ["Sayings of the Century", "Moby Dick", "Sayings of the Century", "Moby Dick"], JsonPath.new(path).on(@object)
+  end
+
+  def test_nested_with_unknown_key_filtered_array
+    path = "$..[?(@['price'] == 9 || @['price'] == 33)].title"
+    assert_equal ["Sayings of the Century", "Moby Dick", "Sayings of the Century", "Moby Dick"], JsonPath.new(path).on(@object)
+  end
+  
+  def test_runtime_error_frozen_string
+    skip('in ruby version below 2.2.0 this error is not raised') if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2.0') || Gem::Version.new(RUBY_VERSION) > Gem::Version::new('2.6')
+    json = '
+    {
+      "test": "something"
+    }
+    '.to_json
+    assert_raises(ArgumentError, "RuntimeError: character '|' not supported in query") do
+      JsonPath.on(json, '$.description|title')
+    end
+  end
+
   def test_delete_more_items
     a = { 'itemList' =>
       [{ 'alfa' => 'beta1' },
@@ -577,7 +933,7 @@ class TestJsonpath < MiniTest::Unit::TestCase
        { 'alfa' => 'beta11' },
        { 'alfa' => 'beta12' }] }
     expected = { 'itemList' => [{ 'alfa' => 'beta1' }] }
-    assert_equal expected, JsonPath.for(a.to_json).delete('$.itemList[1:11:1]').to_hash
+    assert_equal expected, JsonPath.for(a.to_json).delete('$.itemList[1:12:1]').to_hash
   end
 
   def test_delete_more_items_with_stepping
@@ -607,6 +963,277 @@ class TestJsonpath < MiniTest::Unit::TestCase
     assert_equal expected, JsonPath.for(a.to_json).delete('$.itemList[1:6:2]').to_hash
   end
 
+  def test_nested_values
+    json = '
+    {
+      "phoneNumbers": [
+        [{
+          "type"  : "iPhone",
+          "number": "0123-4567-8888"
+        }],
+        [{
+          "type"  : "home",
+          "number": "0123-4567-8910"
+        }]
+      ]
+    }
+    '.to_json
+    assert_equal [[{ 'type' => 'home', 'number' => '0123-4567-8910' }]], JsonPath.on(json, "$.phoneNumbers[?(@[0].type == 'home')]")
+    assert_equal [], JsonPath.on(json, "$.phoneNumbers[?(@[2].type == 'home')]")
+    json = '
+    {
+      "phoneNumbers":
+        {
+          "type"  : "iPhone",
+          "number": "0123-4567-8888"
+        }
+    }
+    '.to_json
+    assert_equal [], JsonPath.on(json, "$.phoneNumbers[?(@[0].type == 'home')]")
+  end
+
+  def test_selecting_multiple_keys_on_hash
+    json = '
+    {
+      "category": "reference",
+      "author": "Nigel Rees",
+      "title": "Sayings of the Century",
+      "price": 8.95
+    }
+    '.to_json
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, '$.(category,author)')
+  end
+
+  def test_selecting_multiple_keys_on_sub_hash
+    skip("Failing as the semantics of .(x,y) is unclear")
+    json = '
+    {
+      "book": {
+        "category": "reference",
+        "author": "Nigel Rees",
+        "title": "Sayings of the Century",
+        "price": 8.95
+      }
+    }
+    '.to_json
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, '$.book.(category,author)')
+  end
+
+  def test_selecting_multiple_keys_on_array
+    json = '
+    {
+      "store": {
+        "book": [
+          {
+            "category": "reference",
+            "author": "Nigel Rees",
+            "title": "Sayings of the Century",
+            "price": 8.95
+          },
+          {
+            "category": "fiction",
+             "author": "Evelyn Waugh",
+             "title": "Sword of Honour",
+             "price": 12.99
+          }
+        ]
+      }
+    }
+    '.to_json
+
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }, { 'category' => 'fiction', 'author' => 'Evelyn Waugh' }], JsonPath.on(json, '$.store.book[*](category,author)')
+  end
+
+  def test_selecting_multiple_keys_on_array_with_filter
+    json = '
+    {
+      "store": {
+        "book": [
+          {
+            "category": "reference",
+            "author": "Nigel Rees",
+            "title": "Sayings of the Century",
+            "price": 8.95
+          },
+          {
+            "category": "fiction",
+             "author": "Evelyn Waugh",
+             "title": "Sword of Honour",
+             "price": 12.99
+          }
+        ]
+      }
+    }
+    '.to_json
+
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, "$.store.book[?(@['price'] == 8.95)](category,author)")
+    assert_equal [{ 'category' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, "$.store.book[?(@['price'] == 8.95)](   category, author   )")
+  end
+
+  def test_selecting_multiple_keys_with_filter_with_space_in_catergory
+    json = '
+    {
+      "store": {
+        "book": [
+          {
+            "cate gory": "reference",
+            "author": "Nigel Rees",
+            "title": "Sayings of the Century",
+            "price": 8.95
+          },
+          {
+            "cate gory": "fiction",
+             "author": "Evelyn Waugh",
+             "title": "Sword of Honour",
+             "price": 12.99
+          }
+        ]
+      }
+    }
+    '.to_json
+
+    assert_equal [{ 'cate gory' => 'reference', 'author' => 'Nigel Rees' }], JsonPath.on(json, "$.store.book[?(@['price'] == 8.95)](   cate gory, author   )")
+  end
+
+  def test_use_symbol_opt
+    json = {
+      store: {
+        book: [
+          {
+            category: "reference",
+            author: "Nigel Rees",
+            title: "Sayings of the Century",
+            price: 8.95
+          },
+          {
+            category: "fiction",
+            author: "Evelyn Waugh",
+            title: "Sword of Honour",
+            price: 12.99
+          }
+        ]
+      }
+    }
+    on = ->(path){ JsonPath.on(json, path, use_symbols: true) }
+    assert_equal ['reference', 'fiction'], on.("$.store.book[*].category")
+    assert_equal ['reference', 'fiction'], on.("$..category")
+    assert_equal ['reference'], on.("$.store.book[?(@['price'] == 8.95)].category")
+    assert_equal [{'category' => 'reference'}], on.("$.store.book[?(@['price'] == 8.95)](category)")
+  end
+
+  def test_object_method_send
+    j = {height: 5, hash: "some_hash"}.to_json
+    hs = JsonPath.new "$..send"
+    assert_equal([], hs.on(j))
+    hs = JsonPath.new "$..hash"
+    assert_equal(["some_hash"], hs.on(j))
+    hs = JsonPath.new "$..send"
+    assert_equal([], hs.on(j))
+    j = {height: 5, send: "should_still_work"}.to_json
+    hs = JsonPath.new "$..send"
+    assert_equal(['should_still_work'], hs.on(j))
+  end
+
+  def test_index_access_by_number
+    data = {
+      '1': 'foo'
+    }
+    assert_equal ['foo'], JsonPath.new('$.1').on(data.to_json)
+  end
+
+  def test_behavior_on_null_and_missing
+    data = {
+      "foo" => nil,
+      "bar" => {
+        "baz" => nil
+      },
+      "bars" => [
+        { "foo" => 12 },
+        { "foo" => nil },
+        { }
+      ]
+    }
+    assert_equal [nil], JsonPath.new('$.foo').on(data)
+    assert_equal [nil], JsonPath.new('$.bar.baz').on(data)
+    assert_equal [], JsonPath.new('$.baz').on(data)
+    assert_equal [], JsonPath.new('$.bar.foo').on(data)
+    assert_equal [12, nil], JsonPath.new('$.bars[*].foo').on(data)
+  end
+
+  def test_default_path_leaf_to_null_opt
+    data = {
+      "foo" => nil,
+      "bar" => {
+        "baz" => nil
+      },
+      "bars" => [
+        { "foo" => 12 },
+        { "foo" => nil },
+        { }
+      ]
+    }
+    assert_equal [nil], JsonPath.new('$.foo', default_path_leaf_to_null: true).on(data)
+    assert_equal [nil], JsonPath.new('$.bar.baz', default_path_leaf_to_null: true).on(data)
+    assert_equal [nil], JsonPath.new('$.baz', default_path_leaf_to_null: true).on(data)
+    assert_equal [nil], JsonPath.new('$.bar.foo', default_path_leaf_to_null: true).on(data)
+    assert_equal [12, nil, nil], JsonPath.new('$.bars[*].foo', default_path_leaf_to_null: true).on(data)
+  end
+
+  def test_raise_max_nesting_error
+    json = {
+      a: {
+        b: {
+          c: {
+          }
+        }
+      }
+    }.to_json
+
+    assert_raises(MultiJson::ParseError) { JsonPath.new('$.a', max_nesting: 1).on(json) }
+  end
+
+  def test_linefeed_in_path_error
+    assert_raises(ArgumentError) { JsonPath.new("$.store\n.book") }
+  end
+
+  def test_with_max_nesting_false
+    json = {
+      a: {
+        b: {
+          c: {
+          }
+        }
+      }
+    }.to_json
+
+    assert_equal [{}], JsonPath.new('$.a.b.c', max_nesting: false).on(json)
+  end
+
+  def test_initialize_with_max_nesting_exceeding_limit
+    json = {
+      a: {
+        b: {
+          c: {
+          }
+        }
+      }
+    }.to_json
+
+    json_obj = JsonPath.new('$.a.b.c', max_nesting: 105)
+    assert_equal [{}], json_obj.on(json)
+    assert_equal false, json_obj.instance_variable_get(:@opts)[:max_nesting]
+  end
+
+  def test_initialize_without_max_nesting_exceeding_limit
+    json_obj = JsonPath.new('$.a.b.c', max_nesting: 90)
+    assert_equal 90, json_obj.instance_variable_get(:@opts)[:max_nesting]
+  end
+
+  def test_initialize_with_max_nesting_false_limit
+    json_obj = JsonPath.new('$.a.b.c', max_nesting: false)
+    assert_equal false, json_obj.instance_variable_get(:@opts)[:max_nesting]
+  end
+
   def example_object
     { 'store' => {
       'book' => [
@@ -658,7 +1285,37 @@ class TestJsonpath < MiniTest::Unit::TestCase
       },
       '@id' => 'http://example.org/store/42',
       '$meta-data' => 'whatevs',
+      'Übermorgen' => 'The day after tomorrow',
+      'Title Case' => 'A title case string',
       '_links' => { 'self' => {} }
     } }
   end
+
+  def test_fetch_all_path
+    data = {
+      "foo" => nil,
+      "bar" => {
+        "baz" => nil
+      },
+      "bars" => [
+        { "foo" => 12 },
+        { "foo" => nil },
+        { }
+      ]
+    }
+    assert_equal ["$", "$.foo", "$.bar", "$.bar.baz", "$.bars", "$.bars[0].foo", "$.bars[0]", "$.bars[1].foo", "$.bars[1]", "$.bars[2]"], JsonPath.fetch_all_path(data)
+  end
+
+
+  def test_extractore_with_dollar_key
+    json = {"test" => {"$" =>"success", "a" => "123"}}
+    assert_equal ["success"],  JsonPath.on(json, "$.test.$")
+    assert_equal ["123"],  JsonPath.on(json, "$.test.a")
+  end
+
+  def test_symbolize_key
+    data = { "store" => { "book" => [{"category" => "reference"}]}}
+    assert_equal [{"category": "reference"}],  JsonPath.new('$..book[0]', symbolize_keys: true).on(data)
+    assert_equal [{"category": "reference"}],  JsonPath.new('$..book[0]').on(data, symbolize_keys: true)
+  end
 end