facter 2.5.7 → 3.9.6.cfacter.20180606

data/ext/facter/cpp-hocon/lib/tests/config_document_parser_test.cc

@@ -0,0 +1,208 @@
+#include <catch.hpp>
+#include <internal/config_document_parser.hpp>
+#include <hocon/parser/config_document_factory.hpp>
+
+#include "test_utils.hpp"
+
+using namespace std;
+using namespace hocon;
+using namespace hocon::test_utils;
+
+shared_ptr<config_node_root> conf_parse(string original_text) {
+    return config_document_parser::parse(
+            token_iterator(fake_origin(),
+                           unique_ptr<istringstream>(new istringstream(original_text)),
+                           true),
+            fake_origin(),
+            config_parse_options());
+}
+
+shared_ptr<config_node_root> json_parse(string original_text) {
+    return config_document_parser::parse(
+            token_iterator(fake_origin(),
+                           unique_ptr<istringstream>(new istringstream(original_text)),
+                           false),
+            fake_origin(),
+            config_parse_options().set_syntax(config_syntax::JSON));
+}
+
+shared_node_value parse_value_conf(string original_text) {
+    return config_document_parser::parse_value(
+            token_iterator(fake_origin(),
+                           unique_ptr<istringstream>(new istringstream(original_text)),
+                           true),
+            fake_origin(),
+            config_parse_options());
+}
+
+shared_node_value parse_value_json(string original_text) {
+    return config_document_parser::parse_value(
+            token_iterator(fake_origin(),
+                           unique_ptr<istringstream>(new istringstream(original_text)),
+                           false),
+            fake_origin(),
+            config_parse_options().set_syntax(config_syntax::JSON));
+}
+
+void parse_values_test(string original_text, bool simple = true, string final_text = "") {
+    string expected = final_text.empty() ? original_text : final_text;
+    auto node = parse_value_conf(original_text);
+    REQUIRE(expected == node->render());
+    if (simple) {
+        REQUIRE(dynamic_pointer_cast<const config_node_simple_value>(node));
+    } else {
+        REQUIRE(dynamic_pointer_cast<const config_node_complex_value>(node));
+    }
+
+    auto json_node = parse_value_json(original_text);
+    REQUIRE(expected == json_node->render());
+    if (simple) {
+        REQUIRE(dynamic_pointer_cast<const config_node_simple_value>(node));
+    } else {
+        REQUIRE(dynamic_pointer_cast<const config_node_complex_value>(node));
+    }
+}
+
+TEST_CASE("parse values", "[doc-parser]") {
+    SECTION("parse simple values") {
+        parse_values_test("123");
+        parse_values_test("123.456");
+        parse_values_test("\"a string\"");
+        parse_values_test("true");
+        parse_values_test("false");
+        parse_values_test("null");
+    }
+
+    SECTION("parse complex values") {
+        parse_values_test("{\"a\": \"b\"}", false);
+        parse_values_test("[\"a\", \"b\", \"c\"]", false);
+    }
+
+    SECTION("parse concatenations in CONF mode") {
+        string original_text = "123 456 \"abc\"";
+        auto node = parse_value_conf(original_text);
+        REQUIRE(original_text == node->render());
+    }
+
+    SECTION("parse keys with no separators and object values in CONF mode") {
+        string original_text = "{\"foo\" { \"bar\" : 12 } }";
+        auto node = parse_value_conf(original_text);
+        REQUIRE(original_text == node->render());
+    }
+}
+
+void invalid_json_test(string original_text, string message) {
+    try {
+        json_parse(original_text);
+    } catch (parse_exception& ex) {
+        REQUIRE(string(ex.what()).find(message) != string::npos);
+    }
+}
+
+TEST_CASE("parse single value errors", "[doc-parser]") {
+    SECTION("illegal leading and trailing whitespace and comments") {
+        REQUIRE_THROWS(parse_value_conf("   123"));
+        REQUIRE_THROWS(parse_value_conf("123   "));
+        REQUIRE_THROWS(parse_value_conf(" 123 "));
+        REQUIRE_THROWS(parse_value_conf("\n123"));
+        REQUIRE_THROWS(parse_value_conf("123\n"));
+        REQUIRE_THROWS(parse_value_conf("\n123\n"));
+        REQUIRE_THROWS(parse_value_conf("#this is a comment\n123#comment"));
+    }
+
+    SECTION("illegal whitespace after concatenation") {
+        REQUIRE_THROWS(parse_value_conf("123 456 789   "));
+    }
+}
+
+TEST_CASE("invalid JSON parse errors", "[doc-parser]") {
+    invalid_json_test("unquotedtext", "Token not allowed in valid JSON");
+
+    SECTION("no substitutions in JSON") {
+        invalid_json_test("${a.b}", "Substitutions (${} syntax) not allowed in JSON");
+    }
+
+    SECTION("no concatenations in JSON") {
+        invalid_json_test("{ \"foo\": 123 456 789 } ", "Expecting close brace '}' or a comma");
+    }
+
+    SECTION("value separators required in JSON") {
+        invalid_json_test("{\"foo\" { \"bar\" : 12 } }", "may not be followed by token: '{'");
+    }
+
+    SECTION("require root element in JSON") {
+        invalid_json_test("\"a\": 123, \"b\": 456", "Document must have an object or array at root");
+    }
+}
+
+TEST_CASE("parse empty document", "[doc-parser]") {
+    auto node = conf_parse("");
+    REQUIRE(dynamic_pointer_cast<const config_node_object>(node->value()));
+    REQUIRE(node->value()->children().empty());
+
+    auto node2 = conf_parse("#comment\n#comment\n\n");
+    REQUIRE(dynamic_pointer_cast<const config_node_object>(node2->value()));
+}
+
+void parse_test_string(string original_text) {
+    auto node = conf_parse(original_text);
+    REQUIRE(original_text == node->render());
+}
+
+TEST_CASE("comprehensive parse test") {
+    SECTION("without curly braces") {
+        parse_test_string("foo:bar");
+        parse_test_string(" foo : bar ");
+        parse_test_string("include \"foo.conf\" ");
+        parse_test_string("   \nfoo:bar\n   ");
+        parse_test_string("aUnquoted: bar\naString = \"qux\"\naNumb:123\naDouble=123.456\naTrue=true\naFalse=false\n"
+                          "aNull=null\naSub =  ${a.b}\ninclude \"foo.conf\"");
+    }
+
+    SECTION("with curly braces") {
+        parse_test_string("{}");
+        parse_test_string("{foo:bar}");
+        parse_test_string("{  foo  :  bar  }");
+        parse_test_string("{foo:bar}    ");
+        parse_test_string("{include \"foo.conf\"}");
+        parse_test_string("  \n{foo:bar}\n  ");
+        parse_test_string("{\naUnquoted: bar\naString = \"qux\"\naNumb:123\naDouble=123.456\naTrue=true\naFalse=false\n"
+                          "aNull=null\naSub =  ${a.b}\ninclude \"foo.conf\"\n}");
+    }
+
+    SECTION("nested maps") {
+        parse_test_string("\nfoo.bar.baz : {\n\tqux : \"abcdefg\"\n\t\"abc\".def.\"ghi\" : 123\n\tabc = "
+                          "{ food:bar }\n}\nqux = 123.456\n");
+    }
+
+    SECTION("comments in maps") {
+        parse_test_string("{\nfoo: bar\n// this is a comment\nbaz:qux // this is another comment\n}");
+    }
+
+    SECTION("arrays") {
+        parse_test_string("[]");
+        parse_test_string("[foo]");
+        parse_test_string("[foo,]");
+        parse_test_string("[foo,]   ");
+        parse_test_string("   \n[]\n   ");
+        parse_test_string("[foo, bar,\"qux\", 123,123.456, true,false, null, ${a.b}]");
+        parse_test_string("[foo,   bar,\"qux\"   , 123  123.456, true,false, null,   ${a.b}   ]");
+    }
+
+    SECTION("basic concatenation") {
+        parse_test_string("[foo bar baz qux]");
+        parse_test_string("{foo: foo bar baz qux}");
+        parse_test_string("[abc 123 123.456 null true false [1, 2, 3] {a:b}, 2]");
+    }
+
+    SECTION("all together now") {
+        parse_test_string("{\nfoo: bar baz   qux    ernie\n// The above was a concatenation\n\nbaz  =  [ abc 123, {a:12\n"
+        "\t\t\t\tb: {\n\t\t\t\t\tc: 13\n\t\t\t\t\td: {\n\t\t\t\t\t\ta: 22\n\t\t\t\t\t\tb: \"abcdefg\" # this is a "
+        "comment\n\t\t\t\t\t\tc: [1, 2, 3]\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t}, # this was an object in an array\n"
+        "\t\t\t\t//The above value is a map containing a map containing a map, all in an array\n\t\t\t\t22,\n"
+        "\t\t\t\t// The below is an array contained in another array\n\t\t\t\t[1,2,3]]\n//This is a map with some "
+        "nested maps and array within it, as well as as some concatenations\nqux {\n\tbaz: abc 123\n\tbar: {\n\t\t"
+        "baz: abcdefg\n\t\tbar: {\n\t\t\ta: null\n\t\t\tb: true\n\t\t\tc: [true false 123, null, [1, 2, 3]]\n\t\t}"
+        "\n\t}\n}\n// Did I cover everything?\n}");
+    }
+}

data/ext/facter/cpp-hocon/lib/tests/config_document_tests.cc

@@ -0,0 +1,110 @@
+#include <catch.hpp>
+#include <hocon/parser/config_document_factory.hpp>
+#include <internal/simple_config_document.hpp>
+#include "fixtures.hpp"
+
+using namespace hocon;
+using namespace std;
+
+void replace_test(string original_text, string final_text, string new_value,
+                  string replace_path, config_syntax syntax) {
+    auto config_doc = config_document_factory::parse_string(original_text,
+                                                            config_parse_options().set_syntax(syntax));
+    REQUIRE(original_text == config_doc->render());
+    auto new_doc = config_doc->with_value_text(replace_path, new_value);
+    REQUIRE(final_text == new_doc->render());
+}
+
+TEST_CASE("replacement of elements in a document", "[config-doc]") {
+    SECTION("replacements in a simple map") {
+        replace_test("{\"a\":1}", "{\"a\":2}", "2", "a", config_syntax::JSON);
+        replace_test("{\"a\":1}", "{\"a\":2}", "2", "a", config_syntax::CONF);
+    }
+
+    SECTION("replacement in a map without braces") {
+        replace_test("a: b\nc = d", "a: b\nc = 12", "12", "c", config_syntax::CONF);
+    }
+
+    string original_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
+        "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": 12\n\t},\n"
+        "\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
+    SECTION("replacements in a complex map") {
+        string final_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
+                "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": "
+                "\"i am now a string\"\n\t},\n\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
+        replace_test(original_text, final_text, "\"i am now a string\"", "h.b.a", config_syntax::JSON);
+        replace_test(original_text, final_text, "\"i am now a string\"", "h.b.a", config_syntax::CONF);
+    }
+
+    SECTION("replace a value with a map") {
+        string final_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
+                "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": "
+                "{\"a\":\"b\", \"c\":\"d\"}\n\t},\n\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
+        replace_test(original_text, final_text, "{\"a\":\"b\", \"c\":\"d\"}", "h.b.a", config_syntax::JSON);
+        replace_test(original_text, final_text, "{\"a\":\"b\", \"c\":\"d\"}", "h.b.a", config_syntax::CONF);
+    }
+
+    SECTION("replace a value with an array") {
+        string final_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
+                "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": "
+                "[1,2,3,4,5]\n\t},\n\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
+        replace_test(original_text, final_text, "[1,2,3,4,5]", "h.b.a", config_syntax::JSON);
+        replace_test(original_text, final_text, "[1,2,3,4,5]", "h.b.a", config_syntax::CONF);
+    }
+
+    SECTION("replace a value with a concatenation") {
+        string final_text = "{\n\"a\":123,\n\"b\": 123.456,\n\"c\": true,\n\"d\": false,\n\"e\": null,\n"
+                "\"f\": \"a string\",\n\"g\": [1,2,3,4,5],\n\"h\": {\n\t\"a\": 123,\n\t\"b\": {\n\t\t\"a\": "
+                "this is a concatenation 123 456 {a:b} [1,2,3] {a: this is another 123 concatenation null true}\n\t},\n"
+                "\"c\": [1, 2, 3, {\"a\": \"b\"}, [1,2,3]]\n}\n}";
+        replace_test(original_text, final_text, "this is a concatenation 123 456 {a:b} [1,2,3] "
+                "{a: this is another 123 concatenation null true}", "h.b.a", config_syntax::CONF);
+    }
+}
+
+TEST_CASE("removal of duplicates", "[config-doc]") {
+    string original_text = "{a: b, a.b.c: d, a: e}";
+    auto config_doc = config_document_factory::parse_string(original_text);
+    REQUIRE("{a: 2}" == config_doc->with_value_text("a", "2")->render());
+
+    original_text = "{a: b, a: e, a.b.c:d}";
+    config_doc = config_document_factory::parse_string(original_text);
+    REQUIRE("{a: 2, }" == config_doc->with_value_text("a", "2")->render());
+
+    original_text = "{a.b.c: d}";
+    config_doc = config_document_factory::parse_string(original_text);
+    REQUIRE("{ a : 2}" == config_doc->with_value_text("a", "2")->render());
+}
+
+TEST_CASE("set new value", "[config-doc]") {
+    SECTION("braced root node") {
+        string original_text = "{\n\t\"a\":\"b\",\n\t\"c\":\"d\"\n}";
+        string final_text_conf = "{\n\t\"a\":\"b\",\n\t\"c\":\"d\"\n\t\"e\" : \"f\"\n}";
+        string final_text_json = "{\n\t\"a\":\"b\",\n\t\"c\":\"d\",\n\t\"e\" : \"f\"\n}";
+        replace_test(original_text, final_text_json, "\"f\"", "\"e\"", config_syntax::JSON);
+        replace_test(original_text, final_text_conf, "\"f\"", "\"e\"", config_syntax::CONF);
+    }
+
+    SECTION("no brace at root node") {
+        string original_text = "\"a\":\"b\",\n\"c\":\"d\"\n";
+        string final_text = "\"a\":\"b\",\n\"c\":\"d\"\n\"e\" : \"f\"\n";
+        replace_test(original_text, final_text, "\"f\"", "\"e\"", config_syntax::CONF);
+    }
+
+    SECTION("multi-level") {
+        string original_text = "a:b\nc:d";
+        string final_text = "a:b\nc:d\ne : {\n  f : {\n    g : 12\n  }\n}";
+        replace_test(original_text, final_text, "12", "e.f.g", config_syntax::CONF);
+
+        original_text = "{\"a\":\"b\",\n\"c\":\"d\"}";
+        final_text = "{\"a\":\"b\",\n\"c\":\"d\",\n  \"e\" : {\n    \"f\" : {\n      \"g\" : 12\n    }\n  }}";
+        replace_test(original_text, final_text, "12", "e.f.g", config_syntax::JSON);
+    }
+}
+
+TEST_CASE("parse from file", "[doc-parser]") {
+    string original_text = "{ a : b }";
+    string directory = TEST_FILE_DIR;
+    auto doc = config_document_factory::parse_file(directory + "/test.conf");
+    REQUIRE(doc->render() == original_text);
+}

data/ext/facter/cpp-hocon/lib/tests/config_node_test.cc

@@ -0,0 +1,338 @@
+#include <catch.hpp>
+
+#include "test_utils.hpp"
+
+#include <limits>
+#include <internal/path_parser.hpp>
+#include <internal/nodes/config_node_object.hpp>
+#include <internal/nodes/config_node_array.hpp>
+#include <internal/nodes/config_node_concatenation.hpp>
+
+using namespace std;
+using namespace hocon;
+using namespace hocon::test_utils;
+
+/*  This test implementation of abstract_config_node allows
+ *  shallow testing of its basic methods.
+ */
+class concrete_config_node : public abstract_config_node {
+public:
+    token_list get_tokens() const { return _tokens; };
+    token_list _tokens;
+};
+
+TEST_CASE("abstract_config_node") {
+    concrete_config_node node;
+    shared_token token1 = hash_comment_token("token1");
+    shared_token token2 = hash_comment_token("token2");
+
+    SECTION("render should return all tokens concatenated together") {
+        node._tokens.push_back(token1);
+        node._tokens.push_back(token2);
+        REQUIRE(node.render() == "#token1#token2");
+    }
+
+    SECTION("render should return an empty string when there are no tokens") {
+        REQUIRE(node.render() == "");
+    }
+
+    SECTION("== operator when objects are equivalent") {
+        concrete_config_node another_node;
+        node._tokens.push_back(token1);
+        another_node._tokens.push_back(token1);
+        REQUIRE(node == another_node);
+    }
+
+    SECTION("== operator when objects are not equivalent") {
+        concrete_config_node another_node;
+        node._tokens.push_back(token1);
+        another_node._tokens.push_back(token2);
+        REQUIRE_FALSE(node == another_node);
+    }
+}
+
+void single_token_test(shared_token t) {
+    config_node_single_token node(t);
+    REQUIRE(node.render() == t->token_text());
+}
+
+TEST_CASE("single tokens", "[config-node]") {
+    SECTION("basic config nodes") {
+        single_token_test(tokens::start_token());
+        single_token_test(tokens::end_token());
+        single_token_test(tokens::open_curly_token());
+        single_token_test(tokens::close_curly_token());
+        single_token_test(tokens::open_square_token());
+        single_token_test(tokens::close_square_token());
+        single_token_test(tokens::comma_token());
+        single_token_test(tokens::colon_token());
+        single_token_test(tokens::plus_equals_token());
+        single_token_test(tokens::equals_token());
+
+        single_token_test(unquoted_text_token("foo"));
+        single_token_test(whitespace_token("   "));
+        single_token_test(line_token(1));
+        single_token_test(double_slash_comment_token("slash comment"));
+        single_token_test(hash_comment_token("hash comment"));
+    }
+}
+
+void simple_value_test(shared_token t, config_value::type type) {
+    config_node_simple_value node(t);
+    // We pass UNSPECIFIED for substitutions, which do not have a config_value::type
+    if (type != config_value::type::UNSPECIFIED) {
+        REQUIRE(type == node.get_value()->value_type());
+    }
+    REQUIRE(node.render() == t->token_text());
+}
+
+TEST_CASE("simple values", "[config-node]") {
+    SECTION("basic value nodes") {
+        simple_value_test(int_token(10, "10"), config_value::type::NUMBER);
+        simple_value_test(double_token(2.5, "2.5"), config_value::type::NUMBER);
+        simple_value_test(bool_token(false), config_value::type::BOOLEAN);
+        simple_value_test(bool_token(true), config_value::type::BOOLEAN);
+        simple_value_test(null_token(), config_value::type::CONFIG_NULL);
+        simple_value_test(string_token("A string."), config_value::type::STRING);
+        simple_value_test(unquoted_text_token("unquoted"), config_value::type::STRING);
+        simple_value_test(substitution_token(string_token("c.d"), false), config_value::type::UNSPECIFIED);
+        simple_value_test(substitution_token(string_token("x.y"), true), config_value::type::UNSPECIFIED);
+        simple_value_test(substitution_token(unquoted_text_token("a.b"), false), config_value::type::UNSPECIFIED);
+    }
+}
+
+TEST_CASE("key nodes", "[config-node]") {
+    REQUIRE(node_key("foo")->render() == "foo");
+    REQUIRE(node_key("\"Hello how are you today?\"")->render() == "\"Hello how are you today?\"");
+}
+
+TEST_CASE("node subpath", "[config-node]") {
+    string original_path = "a.b.c.\"@$%@!#$\".\"\".1234.5678";
+    auto path_node = node_key(original_path);
+
+    REQUIRE(original_path == path_node->render());
+    REQUIRE("c.\"@$%@!#$\".\"\".1234.5678" == path_node->sub_path(2).render());
+    REQUIRE("5678" == path_node->sub_path(6).render());
+}
+
+void field_node_test(shared_ptr<config_node_path> key, shared_node_value value, shared_node_value new_value) {
+    auto key_value_node = node_key_value_pair(key, value);
+    REQUIRE((key->render() + " : " + value->render()) == key_value_node->render());
+    REQUIRE(key->render() == key_value_node->path()->render());
+    REQUIRE(value->render() == key_value_node->get_value()->render());
+
+    auto new_key_value = key_value_node->replace_value(new_value);
+    REQUIRE((key->render() + " : " + new_value->render()) == new_key_value->render());
+    REQUIRE(new_value->render() == new_key_value->get_value()->render());
+}
+
+TEST_CASE("node fields", "[config-node]") {
+    SECTION("supports quoted and unquoted keys") {
+        field_node_test(node_key("\"abc\""), int_node(123), int_node(345));
+        field_node_test(node_key("abc"), int_node(123), int_node(345));
+    }
+
+    SECTION("can replace value with values of different types") {
+        field_node_test(node_key("\"abc\""), int_node(123), string_node("I am a string"));
+        field_node_test(node_key("\"abc\""), int_node(123), make_shared<config_node_object>(
+        shared_node_list { open_brace_node(), close_brace_node() }));
+    }
+}
+
+void top_level_value_replace_test(shared_node_value value,
+                                  shared_node_value new_value,
+                                  string key = "foo")
+{
+    shared_node_list children { open_brace_node(),
+                                node_key_value_pair(node_key(key), value),
+                                close_brace_node() };
+    config_node_object complex { children };
+    auto new_node = complex.set_value_on_path(key, new_value);
+    string original_text = "{" + key + " : " + value->render() + "}";
+    string final_text = "{" + key + " : " + new_value->render() + "}";
+
+    REQUIRE(original_text == complex.render());
+    REQUIRE(final_text == new_node->render());
+}
+
+TEST_CASE("replace nodes", "[config-node]") {
+    SECTION("simple values can be replaced") {
+        top_level_value_replace_test(int_node(10), int_node(15));
+        top_level_value_replace_test(long_node(numeric_limits<int>::max() + 1ll), int_node(1));
+        top_level_value_replace_test(double_node(3.14), int_node(2));
+        top_level_value_replace_test(bool_node(false), bool_node(false));
+        top_level_value_replace_test(bool_node(true), null_node());
+        top_level_value_replace_test(null_node(), string_node("I am a string"));
+        top_level_value_replace_test(string_node("string here!"), unquoted_text_node("thisisunquoted"));
+        top_level_value_replace_test(unquoted_text_node("unquotedtext"), substitution_node(string_token("c.d"), false));
+        top_level_value_replace_test(int_node(10), substitution_node(unquoted_text_token("x.y"), true));
+        top_level_value_replace_test(int_node(10), substitution_node(unquoted_text_token("a.b"), false));
+        top_level_value_replace_test(substitution_node(unquoted_text_token("c.d"), false), int_node(10));
+    }
+
+    auto node_array = make_shared<config_node_array>(shared_node_list {
+            open_brace_node(),
+            int_node(10),
+            space_node(),
+            comma_node(),
+            space_node(),
+            int_node(15),
+            close_brace_node()
+    });
+
+    SECTION("arrays can be replaced") {
+        top_level_value_replace_test(int_node(10), node_array);
+        top_level_value_replace_test(node_array, int_node(10));
+        top_level_value_replace_test(node_array, make_shared<config_node_object>(shared_node_list {
+                open_brace_node(),
+                close_brace_node()
+        }));
+    }
+
+    auto nested_map = make_shared<config_node_object>(
+            shared_node_list { open_brace_node(),
+                               node_key_value_pair(node_key("abc"), string_node("a string")),
+                               close_brace_node()
+            });
+
+    SECTION("objects can be replaced") {
+        top_level_value_replace_test(nested_map, int_node(10));
+        top_level_value_replace_test(int_node(10), nested_map);
+        top_level_value_replace_test(node_array, nested_map);
+        top_level_value_replace_test(nested_map, node_array);
+        top_level_value_replace_test(nested_map,
+                                     make_shared<config_node_object>(shared_node_list { open_brace_node(),
+                                                                                        close_brace_node() }));
+    }
+
+    SECTION("concatenations can be replaced") {
+        auto concat = make_shared<config_node_concatenation>(shared_node_list {
+                int_node(10),
+                space_node(),
+                string_node("hello")
+        });
+
+        top_level_value_replace_test(concat, int_node(10));
+        top_level_value_replace_test(int_node(12), concat);
+        top_level_value_replace_test(nested_map, concat);
+        top_level_value_replace_test(concat, nested_map);
+        top_level_value_replace_test(concat, node_array);
+        top_level_value_replace_test(node_array, concat);
+    }
+
+    SECTION("a.b key format") {
+        top_level_value_replace_test(int_node(10), nested_map, "foo.bar");
+    }
+}
+
+void remove_duplicates_test(shared_node_value value1, shared_node_value value2, shared_node_value value3) {
+    auto key = node_key("foo");
+    auto key_val1 = node_key_value_pair(key, value1);
+    auto key_val2 = node_key_value_pair(key, value2);
+    auto key_val3 = node_key_value_pair(key, value3);
+
+    auto complex = make_shared<config_node_object>(shared_node_list { key_val1, key_val2, key_val3 });
+    string original_text = key_val1->render() + key_val2->render() + key_val3->render();
+    string final_text = key->render() + " : 15";
+
+    REQUIRE(original_text == complex->render());
+    REQUIRE(final_text == complex->set_value_on_path("foo", int_node(15))->render());
+}
+
+TEST_CASE("duplicates of a key are removed from a map", "[config-node]") {
+    auto empty_map_node = make_shared<config_node_object>(shared_node_list { open_brace_node(), close_brace_node() });
+    auto empty_array = make_shared<config_node_array>(shared_node_list { open_brace_node(), close_brace_node() });
+
+    remove_duplicates_test(int_node(10), bool_node(true), null_node());
+    remove_duplicates_test(empty_map_node, empty_map_node, empty_map_node);
+    remove_duplicates_test(empty_array, empty_array, empty_array);
+    remove_duplicates_test(int_node(10), empty_map_node, empty_array);
+}
+
+void nonexistent_path_test(shared_node_value value) {
+    auto node = make_shared<config_node_object>(
+            shared_node_list { node_key_value_pair(node_key("bar"), int_node(15)) });
+    REQUIRE("bar : 15" == node->render());
+    auto new_node = node->set_value_on_path("foo", value);
+    string final_text = "bar : 15, foo : " + value->render();
+    REQUIRE(final_text == new_node->render());
+}
+
+TEST_CASE("creates non-existent paths", "[config-node]") {
+    nonexistent_path_test(int_node(10));
+    nonexistent_path_test(make_shared<config_node_object>(
+            shared_node_list { open_brace_node(),
+                               node_key_value_pair(node_key("foo"), double_node(3.14)),
+                               close_brace_node() }));
+    nonexistent_path_test(make_shared<config_node_array>(shared_node_list {
+            open_brace_node(),
+            int_node(15),
+            close_brace_node()
+    }));
+}
+
+TEST_CASE("replace nested nodes") {
+    string 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\tdef : \"this is a string\""
+                       "\n\t\tghi : ${\"a.b\"}\n\t}\n}\nbaz.abc.ghi "
+                       ": 52\nbaz.abc.ghi : 53\n}";
+    auto lowest_level_map = make_shared<config_node_object>(shared_node_list {
+          open_brace_node(),
+          line_node(6),
+          whitespace_node("\t\t"),
+          node_key_value_pair(node_key("def"), string_node("\"this is a string\"")),
+          line_node(7),
+          whitespace_node("\t\t"),
+          node_key_value_pair(node_key("ghi"), substitution_node(string_token("\"a.b\""), false)),
+          line_node(8),
+          whitespace_node("\t"),
+          close_brace_node()
+    });
+    auto higher_level_map = make_shared<config_node_object>(shared_node_list {
+            open_brace_node(),
+            line_node(2),
+            whitespace_node("\t"),
+            node_key_value_pair(node_key("\"abc.def\""), int_node(123)),
+            line_node(3),
+            whitespace_node("\t"),
+            double_slash_comment_node("this is a comment about the below setting"),
+            line_node(4),
+            line_node(5),
+            whitespace_node("\t"),
+            node_key_value_pair(node_key("abc"), lowest_level_map),
+            line_node(9),
+            close_brace_node()
+    });
+    auto original_node = make_shared<config_node_object>(shared_node_list {
+            node_key_value_pair(node_key("foo"), unquoted_text_node("bar")),
+            line_node(1),
+            node_key_value_pair(node_key("baz"), higher_level_map),
+            line_node(10),
+            node_key_value_pair(node_key("baz.abc.ghi"), int_node(52)),
+            line_node(11),
+            node_key_value_pair(node_key("baz.abc.ghi"), int_node(53)),
+            line_node(12),
+            close_brace_node()
+    });
+    REQUIRE(orig_text == original_node->render());
+
+    string 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\tdef : 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 subpaths
+    auto new_node = original_node->set_value_on_path("baz.\"abc.def\"", bool_node(true));
+    new_node = new_node->set_value_on_path("baz.abc.def", bool_node(false));
+
+    // Repeats are removed from nested maps
+    new_node = new_node->set_value_on_path("baz.abc.ghi", unquoted_text_node("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",
+                                           unquoted_text_node("doesnotexist"));
+
+    REQUIRE(final_text == new_node->render());
+}
+