hocon 0.9.5 → 1.0.1

data/spec/unit/typesafe/config/config_factory_spec.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hocon/config_factory'
+require 'hocon/config_render_options'
+require 'hocon/config_error'
+
+def get_comment_config_hash(config_string)
+  split_config_string = config_string.split("\n")
+  r = Regexp.new('^\s*#')
+
+  previous_string_comment = false
+  hash = {}
+  comment_list = []
+
+  split_config_string.each do |s|
+    if r.match(s)
+      comment_list << s
+      previous_string_comment = true
+    else
+      if previous_string_comment
+        hash[s] = comment_list
+        comment_list = []
+      end
+      previous_string_comment = false
+    end
+  end
+  return hash
+end
+
+describe Hocon::ConfigFactory do
+  let(:render_options) { Hocon::ConfigRenderOptions.defaults }
+
+  before do
+    render_options.origin_comments = false
+    render_options.json = false
+  end
+
+  shared_examples_for "config_factory_parsing" do
+    let(:input_file)  { "#{FIXTURE_DIR}/parse_render/#{example[:name]}/input#{extension}" }
+    let(:output_file) { "#{FIXTURE_DIR}/parse_render/#{example[:name]}/output.conf" }
+    let(:expected)    { example[:hash] }
+    let(:reparsed)    { Hocon::ConfigFactory.parse_file("#{output_file}") }
+    let(:output)      { File.read("#{output_file}") }
+
+    it "should make the config data available as a map" do
+      expect(conf.root.unwrapped).to eq(expected)
+    end
+
+    it "should render the config data to a string with comments intact" do
+      rendered_conf = conf.root.render(render_options)
+      rendered_conf_comment_hash = get_comment_config_hash(rendered_conf)
+      output_comment_hash = get_comment_config_hash(output)
+
+      expect(rendered_conf_comment_hash).to eq(output_comment_hash)
+    end
+
+    it "should generate the same conf data via re-parsing the rendered output" do
+      expect(reparsed.root.unwrapped).to eq(expected)
+    end
+  end
+
+  context "example1" do
+    let(:example) { EXAMPLE1 }
+    let (:extension) { ".conf" }
+
+    context "parsing a HOCON string" do
+      let(:string) { File.open(input_file).read }
+      let(:conf) { Hocon::ConfigFactory.parse_string(string) }
+      include_examples "config_factory_parsing"
+    end
+
+    context "parsing a .conf file" do
+      let(:conf) { Hocon::ConfigFactory.parse_file(input_file) }
+      include_examples "config_factory_parsing"
+    end
+  end
+
+  context "example2" do
+    let(:example) { EXAMPLE2 }
+    let (:extension) { ".conf" }
+
+    context "parsing a HOCON string" do
+      let(:string) { File.open(input_file).read }
+      let(:conf) { Hocon::ConfigFactory.parse_string(string) }
+      include_examples "config_factory_parsing"
+    end
+
+    context "parsing a .conf file" do
+      let(:conf) { Hocon::ConfigFactory.parse_file(input_file) }
+      include_examples "config_factory_parsing"
+    end
+  end
+
+  context "example3" do
+    let (:example) { EXAMPLE3 }
+    let (:extension) { ".conf" }
+
+    context "loading a HOCON file with substitutions" do
+      let(:conf) { Hocon::ConfigFactory.load_file(input_file) }
+      include_examples "config_factory_parsing"
+    end
+  end
+
+  context "example4" do
+    let(:example) { EXAMPLE4 }
+    let (:extension) { ".json" }
+
+    context "parsing a .json file" do
+      let (:conf) { Hocon::ConfigFactory.parse_file(input_file) }
+      include_examples "config_factory_parsing"
+    end
+  end
+
+  context "example5" do
+    it "should raise a ConfigParseError when given an invalid .conf file" do
+      expect{Hocon::ConfigFactory.parse_string("abcdefg")}.to raise_error(Hocon::ConfigError::ConfigParseError)
+    end
+  end
+end

data/spec/unit/typesafe/config/config_node_spec.rb

@@ -0,0 +1,552 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'hocon'
+require 'test_utils'
+
+describe Hocon::Parser::ConfigNode do
+  Tokens = Hocon::Impl::Tokens
+
+  shared_examples_for "single token node test" do
+    it "should render the node with the text of the token" do
+      node = TestUtils.config_node_single_token(token)
+      expect(node.render).to eq(token.token_text)
+    end
+  end
+
+  shared_examples_for "key node test" do
+    it "should render the node with the text of the path" do
+      node = TestUtils.config_node_key(path)
+      expect(path).to eq(node.render)
+    end
+  end
+
+  shared_examples_for "simple value node test" do
+    it "should render the original token text" do
+      node = TestUtils.config_node_simple_value(token)
+      expect(node.render).to eq(token.token_text)
+    end
+  end
+
+  shared_examples_for "field node test" do
+    it "should properly replace the value of a field node" do
+      key_val_node = TestUtils.node_key_value_pair(key, value)
+      expect(key_val_node.render).to eq("#{key.render} : #{value.render}")
+      expect(key_val_node.path.render).to eq(key.render)
+      expect(key_val_node.value.render).to eq(value.render)
+
+      new_key_val_node = key_val_node.replace_value(new_value)
+      expect(new_key_val_node.render).to eq("#{key.render} : #{new_value.render}")
+      expect(new_key_val_node.value.render).to eq(new_value.render)
+    end
+  end
+
+  shared_examples_for "top level value replace test" do
+    it "should replace a value in a ConfigNodeObject" do
+      complex_node_children = [TestUtils.node_open_brace,
+                               TestUtils.node_key_value_pair(TestUtils.config_node_key(key), value),
+                               TestUtils.node_close_brace]
+      complex_node = TestUtils.config_node_object(complex_node_children)
+      new_node = complex_node.set_value_on_path(key, new_value)
+      orig_text = "{#{key} : #{value.render}}"
+      final_text = "{#{key} : #{new_value.render}}"
+
+      expect(complex_node.render).to eq(orig_text)
+      expect(new_node.render).to eq(final_text)
+    end
+  end
+
+  shared_examples_for "replace duplicates test" do
+    it "should remove duplicates of a key when setting a value" do
+      key = TestUtils.config_node_key('foo')
+      key_val_pair_1 = TestUtils.node_key_value_pair(key, value1)
+      key_val_pair_2 = TestUtils.node_key_value_pair(key, value2)
+      key_val_pair_3 = TestUtils.node_key_value_pair(key, value3)
+      complex_node = TestUtils.config_node_object([key_val_pair_1, key_val_pair_2, key_val_pair_3])
+      orig_text = "#{key_val_pair_1.render}#{key_val_pair_2.render}#{key_val_pair_3.render}"
+      final_text = "#{key.render} : 15"
+
+      expect(complex_node.render).to eq(orig_text)
+      expect(complex_node.set_value_on_path("foo", TestUtils.node_int(15)).render).to eq(final_text)
+    end
+  end
+
+  shared_examples_for "non existent path test" do
+    it "should properly add a key/value pair if the key does not exist in the object" do
+      node = TestUtils.config_node_object([TestUtils.node_key_value_pair(TestUtils.config_node_key("bar"), TestUtils.node_int(15))])
+      expect(node.render).to eq('bar : 15')
+      new_node = node.set_value_on_path('foo', value)
+      final_text = "bar : 15, foo : #{value.render}"
+      expect(new_node.render).to eq(final_text)
+    end
+  end
+
+  ########################
+  # ConfigNodeSingleToken
+  ########################
+  context "create basic config node" do
+    # Ensure a ConfigNodeSingleToken can handle all its required token types
+    context "start of file" do
+      let(:token) { Tokens::START }
+      include_examples "single token node test"
+    end
+
+    context "end of file" do
+      let(:token) { Tokens::EOF }
+      include_examples "single token node test"
+    end
+
+    context "{" do
+      let (:token) { Tokens::OPEN_CURLY }
+      include_examples "single token node test"
+    end
+
+    context "}" do
+      let (:token) { Tokens::CLOSE_CURLY }
+      include_examples "single token node test"
+    end
+
+    context "[" do
+      let (:token) { Tokens::OPEN_SQUARE }
+      include_examples "single token node test"
+    end
+
+    context "]" do
+      let (:token) { Tokens::CLOSE_SQUARE }
+      include_examples "single token node test"
+    end
+
+    context "," do
+      let (:token) { Tokens::COMMA }
+      include_examples "single token node test"
+    end
+
+    context "=" do
+      let (:token) { Tokens::EQUALS }
+      include_examples "single token node test"
+    end
+
+    context ":" do
+      let (:token) { Tokens::COLON }
+      include_examples "single token node test"
+    end
+
+    context "+=" do
+      let (:token) { Tokens::PLUS_EQUALS }
+      include_examples "single token node test"
+    end
+
+    context "unquoted text" do
+      let (:token) { TestUtils.token_unquoted('             ') }
+      include_examples "single token node test"
+    end
+
+    context "ignored whitespace" do
+      let (:token) { TestUtils.token_whitespace('             ') }
+      include_examples "single token node test"
+    end
+
+    context '\n' do
+      let (:token) { TestUtils.token_line(1) }
+      include_examples "single token node test"
+    end
+
+    context "double slash comment" do
+      let (:token) { TestUtils.token_comment_double_slash(" this is a double slash comment  ") }
+      include_examples "single token node test"
+    end
+
+    context "hash comment" do
+      let (:token) { TestUtils.token_comment_hash(" this is a hash comment  ") }
+      include_examples "single token node test"
+    end
+  end
+
+  ####################
+  # ConfigNodeSetting
+  ####################
+  context "create config node setting" do
+    # Ensure a ConfigNodeSetting can handle the normal key types
+    context "unquoted key" do
+      let (:path) { "foo" }
+      include_examples "key node test"
+    end
+
+    context "quoted_key" do
+      let (:path) { "\"Hello I am a key how are you today\"" }
+      include_examples "key node test"
+    end
+  end
+
+  context "path node subpath" do
+    it "should produce correct subpaths of path nodes with subpath method" do
+      orig_path = 'a.b.c."@$%#@!@#$"."".1234.5678'
+      path_node = TestUtils.config_node_key(orig_path)
+
+      expect(path_node.render).to eq(orig_path)
+      expect(path_node.sub_path(2).render).to eq('c."@$%#@!@#$"."".1234.5678')
+      expect(path_node.sub_path(6).render).to eq('5678')
+    end
+  end
+
+  ########################
+  # ConfigNodeSimpleValue
+  ########################
+  context "create config node simple value" do
+    context "integer" do
+      let (:token) { TestUtils.token_int(10) }
+      include_examples "simple value node test"
+    end
+
+    context "double" do
+      let (:token) { TestUtils.token_double(3.14159) }
+      include_examples "simple value node test"
+    end
+
+    context "false" do
+      let (:token) { TestUtils.token_false }
+      include_examples "simple value node test"
+    end
+
+    context "true" do
+      let (:token) { TestUtils.token_true }
+      include_examples "simple value node test"
+    end
+
+    context "null" do
+      let (:token) { TestUtils.token_null }
+      include_examples "simple value node test"
+    end
+
+    context "quoted text" do
+      let (:token) { TestUtils.token_string("Hello my name is string") }
+      include_examples "simple value node test"
+    end
+
+    context "unquoted text" do
+      let (:token) { TestUtils.token_unquoted("mynameisunquotedstring") }
+      include_examples "simple value node test"
+    end
+
+    context "key substitution" do
+      let (:token) { TestUtils.token_key_substitution("c.d") }
+      include_examples "simple value node test"
+    end
+
+    context "optional substitution" do
+      let (:token) { TestUtils.token_optional_substitution(TestUtils.token_unquoted("x.y")) }
+      include_examples "simple value node test"
+    end
+
+    context "substitution" do
+      let (:token) { TestUtils.token_substitution(TestUtils.token_unquoted("a.b")) }
+      include_examples "simple value node test"
+    end
+  end
+
+  ####################
+  # ConfigNodeField
+  ####################
+  context "create ConfigNodeField" do
+    let (:key) { TestUtils.config_node_key('"abc"') }
+    let (:value) { TestUtils.node_int(123) }
+
+    context "supports quoted keys" do
+      let (:new_value) { TestUtils.node_int(245) }
+      include_examples "field node test"
+    end
+
+    context "supports unquoted keys" do
+      let (:key) { TestUtils.config_node_key('abc') }
+      let (:new_value) { TestUtils.node_int(245) }
+      include_examples "field node test"
+    end
+
+    context "can replace a simple value with a different type of simple value" do
+      let (:new_value) { TestUtils.node_string('I am a string') }
+      include_examples "field node test"
+    end
+
+    context "can replace a simple value with a complex value" do
+      let (:new_value) { TestUtils.config_node_object([TestUtils.node_open_brace, TestUtils.node_close_brace]) }
+      include_examples "field node test"
+    end
+  end
+
+  ####################
+  # Node Replacement
+  ####################
+  context "replace nodes" do
+    let (:key) { "foo" }
+    array = TestUtils.config_node_array([TestUtils.node_open_bracket, TestUtils.node_int(10), TestUtils.node_space, TestUtils.node_comma,
+                                         TestUtils.node_space, TestUtils.node_int(15), TestUtils.node_close_bracket])
+    nested_map = TestUtils.config_node_object([TestUtils.node_open_brace,
+                                               TestUtils.node_key_value_pair(TestUtils.config_node_key("abc"),
+                                                                             TestUtils.config_node_simple_value(TestUtils.token_string("a string"))),
+                                               TestUtils.node_close_brace])
+
+    context "replace an integer with an integer" do
+      let (:value) { TestUtils.node_int(10) }
+      let (:new_value) { TestUtils.node_int(15) }
+      include_examples "top level value replace test"
+    end
+
+    context "replace a double with an integer" do
+      let (:value) { TestUtils.node_double(3.14159) }
+      let (:new_value) { TestUtils.node_int(10000) }
+      include_examples "top level value replace test"
+    end
+
+    context "replace false with true" do
+      let (:value) { TestUtils.node_false }
+      let (:new_value) { TestUtils.node_true }
+      include_examples "top level value replace test"
+    end
+
+    context "replace true with null" do
+      let (:value) { TestUtils.node_true }
+      let (:new_value) { TestUtils.node_null }
+      include_examples "top level value replace test"
+    end
+
+    context "replace null with a string" do
+      let (:value) { TestUtils.node_null }
+      let (:new_value) { TestUtils.node_string("Hello my name is string") }
+      include_examples "top level value replace test"
+    end
+
+    context "replace a string with unquoted text" do
+      let (:value) { TestUtils.node_string("Hello my name is string") }
+      let (:new_value) { TestUtils.node_unquoted_text("mynameisunquotedstring") }
+      include_examples "top level value replace test"
+    end
+
+    context "replace unquoted text with a key substitution" do
+      let (:value) { TestUtils.node_unquoted_text("mynameisunquotedstring") }
+      let (:new_value) { TestUtils.node_key_substitution("c.d") }
+      include_examples "top level value replace test"
+    end
+
+    context "replace int with an optional substitution" do
+      let (:value) { TestUtils.node_int(10) }
+      let (:new_value) { TestUtils.node_optional_substitution(TestUtils.token_unquoted("x.y")) }
+      include_examples "top level value replace test"
+    end
+
+    context "replace int with a substitution" do
+      let (:value) { TestUtils.node_int(10) }
+      let (:new_value) { TestUtils.node_substitution(TestUtils.token_unquoted("a.b")) }
+      include_examples "top level value replace test"
+    end
+
+    context "replace substitution with an int" do
+      let (:value) { TestUtils.node_substitution(TestUtils.token_unquoted("a.b")) }
+      let (:new_value) { TestUtils.node_int(10) }
+      include_examples "top level value replace test"
+    end
+
+    context "ensure arrays can be replaced" do
+      context "can replace a simple value with an array" do
+        let (:value) { TestUtils.node_int(10) }
+        let (:new_value) { array }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace an array with a simple value" do
+        let (:value) { array }
+        let (:new_value) { TestUtils.node_int(10) }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace an array with another complex value" do
+        let (:value) { array }
+        let (:new_value) { TestUtils.config_node_object([TestUtils.node_open_brace, TestUtils.node_close_brace])}
+        include_examples "top level value replace test"
+      end
+    end
+
+    context "ensure objects can be replaced" do
+      context "can replace an object with a simple value" do
+        let (:value) { nested_map }
+        let (:new_value) { TestUtils.node_int(10) }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace a simple value with an object" do
+        let (:value) { TestUtils.node_int(10) }
+        let (:new_value) { nested_map }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace an array with an object" do
+        let (:value) { array }
+        let (:new_value) { nested_map }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace an object with an array" do
+        let (:value) { nested_map }
+        let (:new_value) { array }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace an object with an empty object" do
+        let (:value) { nested_map }
+        let (:new_value) { TestUtils.config_node_object([TestUtils.node_open_brace, TestUtils.node_close_brace]) }
+        include_examples "top level value replace test"
+      end
+    end
+
+    context "ensure concatenations can be replaced" do
+      concatenation = TestUtils.config_node_concatenation([TestUtils.node_int(10), TestUtils.node_space, TestUtils.node_string("Hello")])
+
+      context "can replace a concatenation with a simple value" do
+        let (:value) { concatenation }
+        let (:new_value) { TestUtils.node_int(12) }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace a simple value with a concatenation" do
+        let (:value) { TestUtils.node_int(12) }
+        let (:new_value) { concatenation }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace an object with a concatenation" do
+        let (:value) { nested_map }
+        let (:new_value) { concatenation }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace a concatenation with an object" do
+        let (:value) { concatenation }
+        let (:new_value) { nested_map }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace an array with a concatenation" do
+        let (:value) { array }
+        let (:new_value) { concatenation }
+        include_examples "top level value replace test"
+      end
+
+      context "can replace a concatenation with an array" do
+        let (:value) { concatenation }
+        let (:new_value) { array }
+        include_examples "top level value replace test"
+      end
+    end
+
+    context 'ensure a key with format "a.b" will be properly replaced' do
+      let (:key) { 'foo.bar' }
+      let (:value) { TestUtils.node_int(10) }
+      let (:new_value) { nested_map }
+      include_examples "top level value replace test"
+    end
+  end
+
+  ####################
+  # Duplicate Removal
+  ####################
+  context "remove duplicates" do
+    empty_map_node = TestUtils.config_node_object([TestUtils.node_open_brace, TestUtils.node_close_brace])
+    empty_array_node = TestUtils.config_node_array([TestUtils.node_open_bracket, TestUtils.node_close_bracket])
+
+    context "duplicates containing simple values will all be removed" do
+      let (:value1) { TestUtils.node_int(10) }
+      let (:value2) { TestUtils.node_true }
+      let (:value3) { TestUtils.node_null }
+      include_examples "replace duplicates test"
+    end
+
+    context "duplicates containing objects will be removed" do
+      let (:value1) { empty_map_node }
+      let (:value2) { empty_map_node }
+      let (:value3) { empty_map_node }
+      include_examples "replace duplicates test"
+    end
+
+    context "duplicates containing arrays will be removed" do
+      let (:value1) { empty_array_node }
+      let (:value2) { empty_array_node }
+      let (:value3) { empty_array_node }
+      include_examples "replace duplicates test"
+    end
+
+    context "duplicates containing a mix of value types will be removed" do
+      let (:value1) { TestUtils.node_int(10) }
+      let (:value2) { empty_map_node }
+      let (:value3) { empty_array_node }
+      include_examples "replace duplicates test"
+    end
+  end
+
+  #################################
+  # Addition of non-existent paths
+  #################################
+  context "add non existent paths" do
+    context "adding an integer" do
+      let (:value) { TestUtils.node_int(10) }
+      include_examples "non existent path test"
+    end
+
+    context "adding an array" do
+      let (:value) { TestUtils.config_node_array([TestUtils.node_open_bracket, TestUtils.node_int(15), TestUtils.node_close_bracket]) }
+      include_examples "non existent path test"
+    end
+
+    context "adding an object" do
+      let (:value) { TestUtils.config_node_object([TestUtils.node_open_brace,
+                                                   TestUtils.node_key_value_pair(TestUtils.config_node_key('foo'),
+                                                                                 TestUtils.node_double(3.14)),
+                                                   TestUtils.node_close_brace]) }
+      include_examples "non existent path test"
+    end
+  end
+
+  #################################
+  # Replacement of nested nodes
+  #################################
+  context "replace nested nodes" do
+    orig_text = "foo : bar\nbaz : {\n\t\"abc.def\" : 123\n\t//This is a comment about the below setting\n\n\tabc : {\n\t\t" +
+        "def : \"this is a string\"\n\t\tghi : ${\"a.b\"}\n\t}\n}\nbaz.abc.ghi : 52\nbaz.abc.ghi : 53\n}"
+    lowest_level_map = TestUtils.config_node_object([TestUtils.node_open_brace, TestUtils.node_line(6), TestUtils.node_whitespace("\t\t"),
+                                                     TestUtils.node_key_value_pair(TestUtils.config_node_key("def"), TestUtils.config_node_simple_value(TestUtils.token_string("this is a string"))),
+                                                     TestUtils.node_line(7), TestUtils.node_whitespace("\t\t"),
+                                                     TestUtils.node_key_value_pair(TestUtils.config_node_key("ghi"), TestUtils.config_node_simple_value(TestUtils.token_key_substitution("a.b"))),
+                                                     TestUtils.node_line(8), TestUtils.node_whitespace("\t"), TestUtils.node_close_brace])
+    higher_level_map = TestUtils.config_node_object([TestUtils.node_open_brace, TestUtils.node_line(2), TestUtils.node_whitespace("\t"),
+                                                     TestUtils.node_key_value_pair(TestUtils.config_node_key('"abc.def"'), TestUtils.config_node_simple_value(TestUtils.token_int(123))),
+                                                     TestUtils.node_line(3), TestUtils.node_whitespace("\t"), TestUtils.node_comment_double_slash("This is a comment about the below setting"),
+                                                     TestUtils.node_line(4), TestUtils.node_line(5), TestUtils.node_whitespace("\t"),
+                                                     TestUtils.node_key_value_pair(TestUtils.config_node_key("abc"), lowest_level_map), TestUtils.node_line(9), TestUtils.node_close_brace])
+    orig_node = TestUtils.config_node_object([TestUtils.node_key_value_pair(TestUtils.config_node_key("foo"), TestUtils.config_node_simple_value(TestUtils.token_unquoted("bar"))),
+                                              TestUtils.node_line(1), TestUtils.node_key_value_pair(TestUtils.config_node_key('baz'), higher_level_map), TestUtils.node_line(10),
+                                              TestUtils.node_key_value_pair(TestUtils.config_node_key('baz.abc.ghi'), TestUtils.config_node_simple_value(TestUtils.token_int(52))),
+                                              TestUtils.node_line(11),
+                                              TestUtils.node_key_value_pair(TestUtils.config_node_key('baz.abc.ghi'), TestUtils.config_node_simple_value(TestUtils.token_int(53))),
+                                              TestUtils.node_line(12), TestUtils.node_close_brace])
+    it "should properly render the original node" do
+      expect(orig_node.render).to eq(orig_text)
+    end
+
+    it "should properly replae values in the original node" do
+      final_text = "foo : bar\nbaz : {\n\t\"abc.def\" : true\n\t//This is a comment about the below setting\n\n\tabc : {\n\t\t" +
+          "def : false\n\t\t\n\t\t\"this.does.not.exist@@@+$#\" : {\n\t\t  end : doesnotexist\n\t\t}\n\t}\n}\n\nbaz.abc.ghi : randomunquotedString\n}"
+
+      # Paths with quotes in the name are treated as a single Path, rather than multiple sub-paths
+      new_node = orig_node.set_value_on_path('baz."abc.def"', TestUtils.config_node_simple_value(TestUtils.token_true))
+      new_node = new_node.set_value_on_path('baz.abc.def', TestUtils.config_node_simple_value(TestUtils.token_false))
+
+      # Repeats are removed from nested maps
+      new_node = new_node.set_value_on_path('baz.abc.ghi', TestUtils.config_node_simple_value(TestUtils.token_unquoted('randomunquotedString')))
+
+      # Missing paths are added to the top level if they don't appear anywhere, including in nested maps
+      new_node = new_node.set_value_on_path('baz.abc."this.does.not.exist@@@+$#".end', TestUtils.config_node_simple_value(TestUtils.token_unquoted('doesnotexist')))
+
+      # The above operations cause the resultant map to be rendered properly
+      expect(new_node.render).to eq(final_text)
+    end
+  end
+
+end