facter 2.5.7 → 3.9.6.cfacter.20180606

data/ext/facter/leatherman/json_container/tests/json_container_test.cc

@@ -0,0 +1,985 @@
+#include <catch.hpp>
+#include <leatherman/json_container/json_container.hpp>
+#include <iostream>
+
+static const std::string JSON = "{\"foo\" : {\"bar\" : 2},"
+                                " \"goo\" : 1,"
+                                " \"bool\" : true,"
+                                " \"string\" : \"a string\","
+                                " \"string_with_null\" : \"a string\\u0000with\\u0000null\","
+                                " \"null\" : null,"
+                                " \"real\" : 3.1415,"
+                                " \"vec\" : [1, 2], "
+                                " \"string_vec\" : [\"one\", \"two\\u0000null\"], "
+                                " \"nested\" : {"
+                                "                  \"foo\" : \"bar\""
+                                "               }"
+                                "}";
+
+namespace leatherman { namespace json_container {
+
+TEST_CASE("JsonContainer::JsonContainer - passing JSON string", "[data]") {
+    std::string json_value {};
+
+    SECTION("it should instantiate by passing any JSON value") {
+        SECTION("object") {
+            json_value = JSON;
+        }
+
+        SECTION("array") {
+            SECTION("of numbers") {
+                json_value = "[1, 2, 3]";
+            }
+
+            SECTION("of booleans") {
+                json_value = "[true, true]";
+            }
+
+            SECTION("of strings") {
+                json_value = "[\"spam\", \"eggs\", \"foo\"]";
+            }
+
+            SECTION("of objects") {
+                json_value = "[" + JSON + ",\n" + JSON + "]";
+            }
+
+            SECTION("of arrays") {
+                json_value = "[[1, 2, 3], [\"spam\", \"eggs\", \"foo\"]]";
+            }
+
+            SECTION("of values of different types") {
+                json_value = "[1, \"spam\",\n" + JSON + "]";
+            }
+        }
+
+        SECTION("std::string instance containing an empty JSON string") {
+            json_value = "\"\"";
+        }
+
+        SECTION("string") {
+            json_value = "\"foo\"";
+        }
+
+        SECTION("number - int") {
+            json_value = "42";
+        }
+
+        SECTION("number - float") {
+            json_value = "3.14159";
+        }
+
+        SECTION("boolean - true") {
+            json_value = "true";
+        }
+
+        SECTION("boolean - false") {
+            json_value = "false";
+        }
+
+        SECTION("null") {
+            json_value = "null";
+        }
+
+        REQUIRE_NOTHROW(JsonContainer { json_value });
+    }
+
+    SECTION("it should throw a data_parse_error in case of empty string") {
+        json_value = "";
+        REQUIRE_THROWS_AS(JsonContainer { json_value }, data_parse_error);
+    }
+
+    SECTION("it should throw a data_parse_error in case of invalid JSON") {
+        SECTION("bad object") {
+            json_value = "{\"foo\" : \"bar\", 42}";
+        }
+
+        SECTION("bad key") {
+            json_value = "{42 : \"bar\"}";
+        }
+
+        SECTION("bad array") {
+            json_value = "1, 2, 3";
+        }
+
+        REQUIRE_THROWS_AS(JsonContainer { json_value }, data_parse_error);
+    }
+}
+
+TEST_CASE("JsonContainer::get for object entries", "[data]") {
+    JsonContainer data { JSON };
+
+    SECTION("it can get a root value") {
+        REQUIRE(data.get<int>("goo") == 1);
+    }
+
+    SECTION("it can get a nested value") {
+        REQUIRE(data.get<int>({"foo", "bar"}) == 2);
+    }
+
+    SECTION("it can get a bool value") {
+        REQUIRE(data.get<bool>("bool") == true);
+    }
+
+    SECTION("it can get a string value") {
+        REQUIRE(data.get<std::string>("string") == "a string");
+    }
+
+    SECTION("it can get a string value containing null character(s)") {
+        REQUIRE(data.get<std::string>("string_with_null") == std::string("a string\0with\0null", 18));
+    }
+
+    SECTION("it can get a double value") {
+        REQUIRE(data.get<double>("real") == 3.1415);
+    }
+
+    SECTION("it can get a vector") {
+        std::vector<int> tmp { 1, 2 };
+        std::vector<int> result { data.get<std::vector<int>>("vec") };
+        REQUIRE(tmp.size() == result.size());
+        REQUIRE(tmp[0] == result[0]);
+        REQUIRE(tmp[1] == result[1]);
+    }
+
+    SECTION("it can get a string vector") {
+        std::vector<std::string> tmp { "one", { "two\0null", 8 } };
+        std::vector<std::string> result { data.get<std::vector<std::string>>("string_vec") };
+        REQUIRE(tmp.size() == result.size());
+        REQUIRE(tmp[0] == result[0]);
+        REQUIRE(tmp[1] == result[1]);
+    }
+
+    SECTION("it can get the root object") {
+      REQUIRE(data.get<JsonContainer>().get<int>("goo") == 1);
+    }
+
+    SECTION("it should behave correctly given a null value") {
+        REQUIRE(data.get<std::string>("null") == "");
+        REQUIRE(data.get<int>("null") == 0);
+        REQUIRE(data.get<bool>("null") == false);
+    }
+
+    SECTION("it can get the root entry") {
+        SECTION("array of numbers") {
+            JsonContainer data_array { "[1, 2, 3]" };
+            auto array = data_array.get<std::vector<int>>();
+            std::vector<int> expected_array { 1, 2, 3 };
+
+            REQUIRE(array == expected_array);
+        }
+
+        SECTION("object") {
+            auto object = data.get<JsonContainer>();
+
+            REQUIRE(object.get<int>("goo") == 1);
+        }
+
+        SECTION("number") {
+            JsonContainer data_number { "42" };
+            auto number = data_number.get<int>();
+
+            REQUIRE(number == 42);
+        }
+    }
+
+    SECTION("it throws a data_key_error in case of unknown object entry") {
+        SECTION("unknown root object entry") {
+            REQUIRE_THROWS_AS(data.get<int>("unknown"), data_key_error);
+        }
+
+        SECTION("unknown nested object entry") {
+            REQUIRE_THROWS_AS(data.get<int>({ "nested", "unknown" }),
+                              data_key_error);
+        }
+    }
+
+    SECTION("it throws a data_type_error in case of mismatch") {
+        SECTION("root entry") {
+            SECTION("not a boolean") {
+                REQUIRE_THROWS_AS(data.get<bool>("string"), data_type_error);
+            }
+
+            SECTION("not an integer") {
+                REQUIRE_THROWS_AS(data.get<int>("real"), data_type_error);
+            }
+
+            SECTION("not a double") {
+                REQUIRE_THROWS_AS(data.get<double>("goo"), data_type_error);
+            }
+
+            SECTION("not a string") {
+                REQUIRE_THROWS_AS(data.get<std::string>("real"), data_type_error);
+            }
+
+            SECTION("array mismatches") {
+                SECTION("not an array") {
+                    REQUIRE_THROWS_AS(data.get<std::vector<int>>("goo"),
+                                      data_type_error);
+                }
+
+                SECTION("mismatch type on array entry") {
+                    REQUIRE_THROWS_AS(data.get<double>("goo"), data_type_error);
+                }
+            }
+        }
+
+        SECTION("nested entry") {
+            data.set<JsonContainer>({ "foo", "spam" }, JsonContainer { JSON });
+
+            SECTION("not a boolean") {
+                REQUIRE_THROWS_AS(data.get<bool>({ "foo", "spam", "string" }),
+                                  data_type_error);
+            }
+
+            SECTION("not an integer") {
+                REQUIRE_THROWS_AS(data.get<int>({ "foo", "spam", "real" }),
+                                  data_type_error);
+            }
+
+            SECTION("not a double") {
+                REQUIRE_THROWS_AS(data.get<double>({ "foo", "spam", "goo" }),
+                                  data_type_error);
+            }
+
+            SECTION("not a string") {
+                REQUIRE_THROWS_AS(data.get<std::string>({ "foo", "spam", "real" }),
+                                  data_type_error);
+            }
+
+            SECTION("array mismatches") {
+                SECTION("not an array") {
+                    REQUIRE_THROWS_AS(
+                        data.get<std::vector<int>>({ "foo", "spam", "goo" }),
+                        data_type_error);
+                }
+
+                SECTION("mismatch type on array entry") {
+                    REQUIRE_THROWS_AS(data.get<double>({ "foo", "spam", "goo" }),
+                                      data_type_error);
+                }
+            }
+        }
+    }
+
+    SECTION("it can always return a JsonContainer instance of an entry") {
+        SECTION("scalars") {
+            SECTION("boolean") {
+                REQUIRE(data.get<JsonContainer>("bool").get<bool>() == true);
+            }
+
+            SECTION("integer") {
+                REQUIRE(data.get<JsonContainer>("goo").get<int>() == 1);
+            }
+
+            SECTION("double") {
+                REQUIRE(data.get<JsonContainer>("real").get<double>() == 3.1415);
+            }
+
+            SECTION("string") {
+                REQUIRE(data.get<JsonContainer>("string").get<std::string>()
+                        == "a string");
+            }
+        }
+
+        SECTION("object") {
+            REQUIRE(data.get<JsonContainer>("nested").get<std::string>("foo")
+                    == "bar");
+        }
+
+        SECTION("array") {
+            std::vector<int> expected_array {1, 2};
+            REQUIRE(data.get<JsonContainer>("vec").get<std::vector<int>>()
+                    == expected_array);
+        }
+    }
+
+    SECTION("it can access array entries") {
+        SECTION("it throws a data_type_error in case of type mismatch") {
+            SECTION("root entry") {
+                JsonContainer a { "[1, 2, 3]" };
+                REQUIRE_THROWS_AS(a.get<std::string>(1), data_type_error);
+            }
+
+            SECTION("object entry") {
+                REQUIRE_THROWS_AS(data.get<std::string>("vec", 1),
+                                  data_type_error);
+            }
+        }
+
+        SECTION("it throws a data_index_error in case of index out of bounds") {
+            SECTION("root entry") {
+                JsonContainer a { "[1, 2, 3]" };
+                REQUIRE_THROWS_AS(a.get<int>(10), data_index_error);
+            }
+
+            SECTION("object entry") {
+                REQUIRE_THROWS_AS(data.get<int>("vec", 10), data_index_error);
+            }
+        }
+
+        SECTION("it can get a value") {
+            SECTION("boolean") {
+                JsonContainer b { "[false, false, true, false]" };
+                REQUIRE_FALSE(b.get<bool>(3));
+            }
+
+            SECTION("integer") {
+                JsonContainer i { "[1, 2, 3]" };
+                REQUIRE(i.get<int>(1) == 2);
+            }
+
+            SECTION("double") {
+                JsonContainer d { "[3.14, 2.718]" };
+                REQUIRE(d.get<double>(1) == 2.718);
+            }
+
+            SECTION("string") {
+                JsonContainer s { "[\"one\", \"two\"]" };
+                REQUIRE(s.get<std::string>(1) == "two");
+            }
+
+            SECTION("object") {
+                JsonContainer o { "[ {\"spam\":\"eggs\"}, {\"foo\":\"bar\"} ]" };
+                auto retrieved_o = o.get<JsonContainer>(0);
+
+                REQUIRE(retrieved_o.size() == 1u);
+                REQUIRE(retrieved_o.get<std::string>("spam") == "eggs");
+            }
+
+            SECTION("array") {
+                JsonContainer a { "[ [1, 2], [false, true], [\"ab\", \"cd\"] ]" };
+                std::vector<bool> e_a { false, true };
+
+                REQUIRE(a.get<std::vector<bool>>(1) == e_a);
+            }
+        }
+
+        SECTION("array with values of different types") {
+            JsonContainer a { "[ 1, \"foo\", true, [2.718, 3.14], 42, 42.0, "
+                              "{\"spam\":\"eggs\"} ]" };
+
+            SECTION("boolean") {
+                REQUIRE(a.get<bool>(2));
+            }
+
+            SECTION("integer") {
+                REQUIRE(a.get<int>(0) == 1);
+            }
+
+            SECTION("double") {
+                REQUIRE(a.get<double>(5) == 42.0);
+            }
+
+            SECTION("string") {
+                REQUIRE(a.get<std::string>(1) == "foo");
+            }
+
+            SECTION("object") {
+                auto retrieved_o = a.get<JsonContainer>(6);
+
+                REQUIRE(retrieved_o.size() == 1u);
+                REQUIRE(retrieved_o.get<std::string>("spam") == "eggs");
+            }
+
+            SECTION("array") {
+                std::vector<double> expected_array { 2.718, 3.14 };
+
+                REQUIRE(a.get<std::vector<double>>(3) == expected_array);
+            }
+        }
+    }
+}
+
+TEST_CASE("JsonContainer::getWithDefault", "[data]") {
+    JsonContainer data { JSON };
+    JsonContainer data_a { "[1, 2, 3]" };
+    std::vector<int> ints { 1, 2, 3 };
+    std::vector<double> doubles { 1.0, 2.0, 3.0 };
+    std::vector<bool> bools { false, true, false };
+    std::vector<std::string> strings { "foo", "bar", "baz" };
+
+    SECTION("it can provide a default value if a root entry key is not found") {
+        REQUIRE(data.getWithDefault<int>("dne", 42) == 42);
+        REQUIRE(data.getWithDefault<double>("dne", 42.0) == 42.0);
+        REQUIRE(data.getWithDefault<bool>("dne", true) == true);
+        REQUIRE(data.getWithDefault<std::string>("dne", "foo") == "foo");
+        REQUIRE(data.getWithDefault<std::vector<int>>("dne", ints) == ints);
+        REQUIRE(data.getWithDefault<std::vector<double>>("dne", doubles) == doubles);
+        REQUIRE(data.getWithDefault<std::vector<bool>>("dne", bools) == bools);
+        REQUIRE(data.getWithDefault<std::vector<std::string>>("dne", strings) == strings);
+    }
+
+    SECTION("throw a data_type_error if the root entry is not an object") {
+        REQUIRE_THROWS_AS(data_a.getWithDefault<int>("foo", 42), data_type_error);
+    }
+
+    SECTION("it can provide a default value if a nested key is not found") {
+        JsonContainer lv_2 {};
+        lv_2.set<JsonContainer>("entry_3", data);
+        JsonContainer lv_1 {};
+        lv_1.set<JsonContainer>("entry_2", lv_2);
+        std::vector<JsonContainerKey> missing_entry { "entry_2", "entry_3", "dne" };
+
+        REQUIRE(lv_1.getWithDefault<int>(missing_entry, 42) == 42);
+        REQUIRE(lv_1.getWithDefault<double>(missing_entry, 42.0) == 42.0);
+        REQUIRE(lv_1.getWithDefault<bool>(missing_entry, true) == true);
+        REQUIRE(lv_1.getWithDefault<std::string>(missing_entry, "foo")
+                == "foo");
+        REQUIRE(lv_1.getWithDefault<std::vector<int>>(missing_entry, ints)
+                == ints);
+        REQUIRE(lv_1.getWithDefault<std::vector<double>>(missing_entry, doubles)
+                == doubles);
+        REQUIRE(lv_1.getWithDefault<std::vector<bool>>(missing_entry, bools)
+                == bools);
+        REQUIRE(lv_1.getWithDefault<std::vector<std::string>>(missing_entry, strings)
+                == strings);
+    }
+
+    SECTION("throw a data_type_error if the parent of a nested entry is not an object") {
+        JsonContainer more_data_a {};
+        more_data_a.set<std::vector<int>>("ints_entry", ints);
+
+        REQUIRE_THROWS_AS(more_data_a.getWithDefault<int>({ "ints_entry", "foo" }, 42),
+                          data_type_error);
+    }
+}
+
+TEST_CASE("JsonContainer::toString", "[data]") {
+    SECTION("root entry") {
+        SECTION("object") {
+            JsonContainer o {};
+            o.set<std::string>("spam", "eggs");
+            REQUIRE(o.toString() == "{\"spam\":\"eggs\"}");
+        }
+
+        SECTION("array") {
+            JsonContainer a { "[1, 2, 3]" };
+            REQUIRE(a.toString() == "[1,2,3]");
+        }
+
+        SECTION("multi type array") {
+            JsonContainer mt_a { "[1, false, \"s\"]" };
+            REQUIRE(mt_a.toString() == "[1,false,\"s\"]");
+        }
+
+        SECTION("scalar") {
+            JsonContainer s { "42" };
+            REQUIRE(s.toString() == "42");
+        }
+    }
+
+    JsonContainer data { JSON };
+
+    SECTION("root object entry") {
+        REQUIRE(data.toString("goo") == "1");
+    }
+
+    SECTION("nested object entry") {
+        REQUIRE(data.toString({ "nested", "foo" }) == "\"bar\"");
+    }
+}
+
+TEST_CASE("JsonContainer::toPrettyString", "[data]") {
+    SECTION("does not throw when the root is") {
+        SECTION("a string") {
+            JsonContainer data_s { "\"some text\"" };
+            REQUIRE_NOTHROW(data_s.toPrettyString());
+        }
+
+        SECTION("an array") {
+            JsonContainer data_a { "[1, 2, 3]" };
+            REQUIRE_NOTHROW(data_a.toPrettyString());
+        }
+
+        SECTION("an object") {
+            JsonContainer data_o { JSON };
+            REQUIRE_NOTHROW(data_o.toPrettyString());
+        }
+
+        SECTION("an object containing nested objects with an array") {
+            JsonContainer data_ooa {};
+            JsonContainer tmp {};
+            tmp.set<std::vector<int>>("bar", { 1, 2, 3 });
+            JsonContainer tmp_two {};
+            tmp_two.set<JsonContainer>("spam", tmp);
+            tmp_two.set<std::vector<int>>("beans", { 55, 56, 57 });
+            JsonContainer tmp_three {};
+            tmp_three.set<JsonContainer>("eggs", tmp_two);
+            data_ooa.set<JsonContainer>("foo", tmp_three);
+
+            REQUIRE_NOTHROW(data_ooa.toPrettyString());
+        }
+    }
+}
+
+TEST_CASE("JsonContainer::empty", "[data]") {
+    SECTION("works correctly for an empty JsonContainer instance") {
+        JsonContainer data {};
+        REQUIRE(data.empty());
+    }
+
+    SECTION("works correctly if the root is an empty array") {
+        JsonContainer data {  "[]" };
+        REQUIRE(data.empty());
+    }
+
+    SECTION("works correctly for an non-empty JsonContainer instance") {
+        JsonContainer data {};
+        data.set<int>("spam", 1);
+        REQUIRE_FALSE(data.empty());
+    }
+
+    SECTION("works correctly if the root is an non-empty array") {
+        JsonContainer data {  "[1, 2, 3]" };
+        REQUIRE_FALSE(data.empty());
+    }
+}
+
+TEST_CASE("JsonContainer::size", "[data]") {
+    SECTION("works correctly on the root (no key argument)") {
+        SECTION("empty object") {
+            JsonContainer data {};
+            REQUIRE(data.size() == 0u);
+        }
+
+        SECTION("the root is an empty array") {
+            JsonContainer data {  "[]" };
+            REQUIRE(data.size() == 0u);
+        }
+
+        SECTION("non-empty singleton object") {
+            JsonContainer data {};
+            data.set<int>("spam", 1);
+            REQUIRE(data.size() == 1u);
+        }
+
+        SECTION("non-empty multi element object") {
+            JsonContainer bigger_data { JSON };
+            REQUIRE(bigger_data.size() == 10u);
+        }
+
+        SECTION("non-empty array") {
+            JsonContainer data {  "[1, 2, 3]" };
+            REQUIRE(data.size() == 3u);
+        }
+    }
+
+    JsonContainer data { JSON };
+
+    SECTION("works correctly on an object entry") {
+        SECTION("entry is a scalar") {
+            REQUIRE(data.size("goo") == 0u);
+        }
+
+        SECTION("entry is an object") {
+            REQUIRE(data.size("foo") == 1u);
+        }
+
+        SECTION("entry is an array") {
+            REQUIRE(data.size("vec") == 2u);
+        }
+    }
+
+    SECTION("works correctly on a nested entry") {
+        data.set<JsonContainer>({ "foo", "spam" }, JsonContainer { JSON });
+
+        SECTION("entry is a scalar") {
+            REQUIRE(data.size({ "foo", "spam", "goo" }) == 0u);
+        }
+
+        SECTION("entry is an object") {
+            REQUIRE(data.size({ "foo", "spam", "nested" }) == 1u);
+        }
+
+        SECTION("entry is an array") {
+            REQUIRE(data.size({ "foo", "spam", "vec" }) == 2u);
+        }
+    }
+}
+
+TEST_CASE("JsonContainer::includes", "[data]") {
+    SECTION("does not throw for an empty JsonContainer instance") {
+        JsonContainer data {};
+        REQUIRE_FALSE(data.includes("foo"));
+    }
+
+    SECTION("it should not throw if the root is not a JSON object") {
+        JsonContainer data { "[1, 2, 3]" };
+        REQUIRE_FALSE(data.includes("foo"));
+    }
+
+    SECTION("Document/object lookups") {
+        JsonContainer msg { JSON };
+        REQUIRE(msg.includes("foo") == true);
+        REQUIRE(msg.includes({ "foo", "bar" }) == true);
+        REQUIRE(msg.includes({ "foo", "baz" }) == false);
+    }
+
+    SECTION("Non object/document lookups") {
+        JsonContainer msg { "\"foo\"" };
+        REQUIRE(msg.includes({ "bar", "bar" }) == false);
+        REQUIRE(msg.includes("foo") == false);
+    }
+}
+
+TEST_CASE("JsonContainer::set", "[data]") {
+    JsonContainer msg {};
+
+    SECTION("it should add a new pair to the root") {
+        msg.set<int>("foo", 4);
+        REQUIRE(msg.get<int>("foo") == 4);
+    }
+
+    SECTION("it allows the creation of a nested structure") {
+        msg.set<int>({"level1", "level21"}, 0);
+        msg.set<bool>("bool1", true);
+        msg.set<std::string>({"level1", "level22"}, "a string");
+        msg.set<std::string>("level11", "different string");
+        REQUIRE(msg.get<int>({ "level1", "level21" }) == 0);
+        REQUIRE(msg.get<bool>("bool1") == true);
+        REQUIRE(msg.get<std::string>({"level1", "level22"}) == "a string");
+        REQUIRE(msg.get<std::string>("level11") == "different string");
+    }
+
+    SECTION("it allows resetting an integer value") {
+        msg.set<int>("i entry", 0);
+        REQUIRE(msg.includes("i entry"));
+        REQUIRE(msg.get<int>("i entry") == 0);
+
+        msg.set<int>("i entry", 5);
+        REQUIRE(msg.get<int>("i entry") == 5);
+    }
+
+    SECTION("it allows resetting a double value") {
+        msg.set<double>("d entry", 3.14159);
+        REQUIRE(msg.includes("d entry"));
+        REQUIRE(msg.get<double>("d entry") == 3.14159);
+
+        msg.set<double>("d entry", 2.71828);
+        REQUIRE(msg.get<double>("d entry") == 2.71828);
+    }
+
+    SECTION("it allows resetting a boolean value") {
+        msg.set<bool>("b entry", true);
+        REQUIRE(msg.includes("b entry"));
+        REQUIRE(msg.get<bool>("b entry") == true);
+
+        msg.set<bool>("b entry", false);
+        REQUIRE(msg.get<bool>("b entry") == false);
+    }
+
+    SECTION("it allows resetting a string value") {
+        msg.set<std::string>("s entry", "bar");
+        REQUIRE(msg.includes("s entry"));
+        REQUIRE(msg.get<std::string>("s entry") == "bar");
+
+        msg.set<std::string>("s entry", "spam");
+        REQUIRE(msg.get<std::string>("s entry") == "spam");
+    }
+
+    SECTION("it allows resetting a string vector value") {
+        std::vector<std::string> s_v { "foo", "bar" };
+        msg.set<std::vector<std::string>>("s_v entry", s_v);
+        REQUIRE(msg.includes("s_v entry"));
+        REQUIRE(msg.get<std::vector<std::string>>("s_v entry") == s_v);
+
+        std::vector<std::string> s_v_other { "spam", "eggs" };
+        msg.set<std::vector<std::string>>("s_v entry", s_v_other);
+        REQUIRE(msg.get<std::vector<std::string>>("s_v entry") == s_v_other);
+    }
+
+    SECTION("it allows resetting a JsonContainer value") {
+        JsonContainer d {};
+        d.set<int>("i", 1);
+
+        msg.set<JsonContainer>("d_c entry", d);
+        auto i_entry = msg.get<JsonContainer>("d_c entry");
+
+        // Expecting msg = { "d_c entry" : {"i" : 1} }
+        REQUIRE(msg.includes("d_c entry"));
+        REQUIRE(i_entry.get<int>("i") == 1);
+
+        JsonContainer d_other {};
+        d_other.set<bool>("b", true);
+
+        msg.set<JsonContainer>("d_c entry", d_other);
+        auto b_entry = msg.get<JsonContainer>("d_c entry");
+
+        // Expecting msg = { "d_c entry" : {"b" : true} }
+        REQUIRE(b_entry.get<bool>("b"));
+    }
+
+    SECTION("it can set a key to a vector") {
+        std::vector<std::string> strings { "foo", "bar" };
+        msg.set<std::vector<std::string>>("sv", strings);
+
+        std::vector<int> ints { 4, 2 };
+        msg.set<std::vector<int>>("iv", ints);
+
+        std::vector<bool> bools { true, false };
+        msg.set<std::vector<bool>>("bv", bools);
+
+        std::vector<double> doubles { 0.00, 9.99 };
+        msg.set<std::vector<double>>("dv", doubles);
+
+        REQUIRE(msg.get<std::vector<std::string>>("sv")[0] == "foo");
+        REQUIRE(msg.get<std::vector<std::string>>("sv")[1] == "bar");
+
+        REQUIRE(msg.get<std::vector<int>>("iv")[0] == 4);
+        REQUIRE(msg.get<std::vector<int>>("iv")[1] == 2);
+
+        REQUIRE(msg.get<std::vector<bool>>("bv")[0] == true);
+        REQUIRE(msg.get<std::vector<bool>>("bv")[1] == false);
+
+        REQUIRE(msg.get<std::vector<double>>("dv")[0] == 0.00);
+        REQUIRE(msg.get<std::vector<double>>("dv")[1] == 9.99);
+    }
+
+    SECTION("it should throw a data_key_error in case root is not an object") {
+        std::string json_array { "[1, 2, 3]" };
+        JsonContainer data_array { json_array };
+
+        REQUIRE_THROWS_AS(data_array.set<std::string>("foo", "bar"),
+                          data_key_error);
+    }
+
+    SECTION("it should throw a data_key_error in case a known inner key is not "
+            "associated with a JSON object") {
+        JsonContainer d_c { JSON };
+
+        REQUIRE_THROWS_AS(d_c.set<std::string>({ "vec", "foo" }, "bar"),
+                          data_key_error);
+    }
+}
+
+TEST_CASE("JsonContainer::keys", "[data]") {
+    SECTION("It returns a vector of keys") {
+        JsonContainer data { "{ \"a\" : 1, "
+                             " \"b\" : 2, "
+                             " \"c\\u0000null\" : 2}" };
+        std::vector<std::string> expected_keys { "a", "b", { "c\0null", 6 } };
+
+        REQUIRE(data.keys() == expected_keys);
+    }
+
+    SECTION("It returns an empty vector when the JsonContainer is empty") {
+        JsonContainer data {};
+        REQUIRE(data.keys().size() == 0u);
+    }
+
+    SECTION("It returns an empty vector when the JsonContainer is an array") {
+        JsonContainer data_array { "[1, 2, 3]" };
+        REQUIRE(data_array.keys().size() == 0u);
+    }
+}
+
+TEST_CASE("JsonContainer::type", "[data]") {
+    JsonContainer data {};
+
+    SECTION("When no key is passed it retrieves the type of the root value") {
+        SECTION("array") {
+            JsonContainer data_array { "[1, 2, 3]" };
+            REQUIRE(data_array.type() == DataType::Array);
+        }
+
+        SECTION("object") {
+            data.set<bool>("b_entry", false);
+            REQUIRE(data.type() == DataType::Object);
+        }
+
+        SECTION("integer") {
+            JsonContainer data_number { "42" };
+            REQUIRE(data_number.type() == DataType::Int);
+        }
+    }
+
+    SECTION("When a single key is passed") {
+        SECTION("it throws a data_key_error if the key is unknown") {
+            REQUIRE_THROWS_AS(data.type("foo"),
+                              data_key_error);
+        }
+
+        SECTION("it can distinguish a Bool (false) value") {
+            data.set<bool>("b_entry", false);
+            REQUIRE(data.type("b_entry") == DataType::Bool);
+        }
+
+        SECTION("it can distinguish a Bool (true) value") {
+            data.set<bool>("b_entry", true);
+            REQUIRE(data.type("b_entry") == DataType::Bool);
+        }
+
+        SECTION("it can distinguish an Object (JsonContainer) value") {
+            JsonContainer tmp {};
+            tmp.set<std::string>("eggs", "spam");
+            data.set<JsonContainer>("obj_entry", tmp);
+            REQUIRE(data.type("obj_entry") == DataType::Object);
+        }
+
+        SECTION("it can distinguish an Array value") {
+            std::vector<std::string> tmp { "one", "two", "three" };
+            data.set<std::vector<std::string>>("array_entry", tmp);
+            REQUIRE(data.type("array_entry") == DataType::Array);
+        }
+
+        SECTION("it can distinguish a String value") {
+            data.set<std::string>("eggs", "spam");
+            REQUIRE(data.type("eggs") == DataType::String);
+        }
+
+        SECTION("it can distinguish an Int value") {
+            data.set<int>("int_entry", 42);
+            REQUIRE(data.type("int_entry") == DataType::Int);
+        }
+
+        SECTION("it can distinguish a Double value") {
+            SECTION("defined by set") {
+                data.set<double>("d_entry", 2.71828);
+                REQUIRE(data.type("d_entry") == DataType::Double);
+            }
+
+            SECTION("defined by JSON string given to the ctor") {
+                JsonContainer data_number { "2.71828" };
+                REQUIRE(data_number.type() == DataType::Double);
+            }
+        }
+
+        SECTION("it can distinguish a null value") {
+            JsonContainer data_with_null { "{\"the_null\" : null}" };
+            REQUIRE(data_with_null.type("the_null") == DataType::Null);
+        }
+    }
+
+    SECTION("When multiple keys are passed") {
+        JsonContainer tmp {};
+        data.set<JsonContainer>("stuff", tmp);
+
+        SECTION("it throws a data_key_error if a key is unknown") {
+            REQUIRE_THROWS_AS(data.type({ "stuff", "bar" }),
+                              data_key_error);
+        }
+
+        SECTION("it can distinguish a Bool (false) value") {
+            data.set<bool>({ "stuff", "b_entry" }, false);
+            REQUIRE(data.type({ "stuff", "b_entry" }) == DataType::Bool);
+        }
+
+        SECTION("it can distinguish a Bool (true) value") {
+            data.set<bool>({ "stuff", "b_entry" }, true);
+            REQUIRE(data.type({ "stuff", "b_entry" }) == DataType::Bool);
+        }
+
+        SECTION("it can distinguish an Object (JsonContainer) value") {
+            JsonContainer tmp {};
+            tmp.set<std::string>("eggs", "spam");
+            data.set<JsonContainer>({ "stuff", "obj_entry" }, tmp);
+            REQUIRE(data.type({ "stuff", "obj_entry" }) == DataType::Object);
+        }
+
+        SECTION("it can distinguish an Array value") {
+            std::vector<std::string> tmp { "one", "two", "three" };
+            data.set<std::vector<std::string>>({ "stuff", "array_entry" }, tmp);
+            REQUIRE(data.type({ "stuff", "array_entry" }) == DataType::Array);
+        }
+
+        SECTION("it can distinguish a String value") {
+            data.set<std::string>({ "stuff", "eggs" }, "spam");
+            REQUIRE(data.type({ "stuff", "eggs" }) == DataType::String);
+        }
+
+        SECTION("it can distinguish an Int value") {
+            data.set<int>({ "stuff", "int_entry" }, 42);
+            REQUIRE(data.type({ "stuff", "int_entry" }) == DataType::Int);
+        }
+
+        SECTION("it can distinguish a Double value") {
+            data.set<double>({ "stuff", "d_entry" }, 2.71828);
+            REQUIRE(data.type({ "stuff", "d_entry" }) == DataType::Double);
+        }
+
+        SECTION("it can distinguish a null value") {
+            JsonContainer data_with_null { "{\"the_null\" : null}" };
+            data.set<JsonContainer>({ "stuff", "more_stuff" }, data_with_null);
+            auto data_type = data.type({ "stuff", "more_stuff", "the_null" });
+            REQUIRE(data_type == DataType::Null);
+        }
+    }
+}
+
+TEST_CASE("JsonContainer::type for arrays entries", "[data]") {
+    JsonContainer data { "[false, -42, 3.14, \"spam\", {\"foo\" : [3, true]}, "
+                         "[1, 2, 3, 4] ]" };
+
+    SECTION("root entry") {
+        SECTION("array") {
+            JsonContainer not_an_aray { JSON };
+            REQUIRE_THROWS_AS(not_an_aray.type(1), data_type_error);
+        }
+
+        SECTION("array with values of different types") {
+            JsonContainer data_array { "[1, \"spam\", false]" };
+            REQUIRE(data_array.type() == DataType::Array);
+        }
+
+        SECTION("boolean") {
+            REQUIRE(data.type(0) == DataType::Bool);
+        }
+
+        SECTION("integer") {
+            REQUIRE(data.type(1) == DataType::Int);
+        }
+
+        SECTION("double") {
+            REQUIRE(data.type(2) == DataType::Double);
+        }
+
+        SECTION("string") {
+            REQUIRE(data.type(3) == DataType::String);
+        }
+
+        SECTION("object") {
+            REQUIRE(data.type(4) == DataType::Object);
+        }
+
+        SECTION("array") {
+            REQUIRE(data.type(5) == DataType::Array);
+        }
+    }
+
+    SECTION("object entry") {
+        JsonContainer o { JSON };
+        o.set<JsonContainer>("multi type array", data);
+
+        SECTION("container") {
+            REQUIRE(o.type("multi type array") == DataType::Array);
+        }
+
+        SECTION("double") {
+            REQUIRE(o.type("multi type array", 2) == DataType::Double);
+        }
+
+        SECTION("string") {
+            REQUIRE(o.type("multi type array", 3) == DataType::String);
+        }
+    }
+
+    SECTION("nested entry") {
+        JsonContainer o { JSON };
+        o.set<JsonContainer>({ "nested", "multi type array" }, data);
+
+        SECTION("container") {
+            REQUIRE(o.type({ "nested", "multi type array" }) == DataType::Array);
+        }
+
+        SECTION("double") {
+            REQUIRE(o.type({ "nested", "multi type array" }, 2)
+                    == DataType::Double);
+        }
+
+        SECTION("string") {
+            REQUIRE(o.type({ "nested", "multi type array" }, 3)
+                    == DataType::String);
+        }
+    }
+}
+
+}}  // namespace leatherman::json_container