issue: 4545376 reject JSON keys containing dots

This change enforces a single conf format by rejecting JSON keys
that contain dots, preventing ambiguous configurations where both flat
dot notation and nested object structures could be used.

Changes:
- Add validation in json_loader::process_json_object() to throw
  xlio_exception when keys contain dots
- Convert key to std::string for proper validation
- Add comprehensive unit tests covering:
  * Method A rejection (flat dot notation like "resources.memory_limit")
  * Method B acceptance (proper nested objects)
  * Edge cases (multiple dots, leading/trailing dots, dots-only keys)
  * Valid keys without dots still work correctly

This resolves the issue where both configuration methods were accepted:
- Method A: "core": {"resources.memory_limit": "50GB"}  (now rejected)
- Method B: "core": {"resources": {"memory_limit": "50GB"}} (works)

Signed-off-by: Tomer Cabouly <[email protected]>

Author: tomerdbz

src/core/config/loaders/json_loader.cpp

@@ -45,7 +45,13 @@ void json_loader::process_json_object(const std::string &prefix, json_object *ob
 {
     json_object_object_foreach(obj, key, value)
     {
-        std::string current_key = prefix.empty() ? key : (prefix + config_strings::misc::DOT + key);
+        std::string key_str(key);
+        if (key_str.find('.') != std::string::npos) {
+            throw_xlio_exception("Key cannot contain dots: " + key_str);
+        }
+
+        std::string current_key =
+            prefix.empty() ? std::move(key_str) : (prefix + config_strings::misc::DOT + key_str);
 
         json_type type = json_object_get_type(value);
         if (type == json_type_object) {

tests/unit_tests/config/json_loader.cpp

@@ -170,6 +170,110 @@ TEST(config, json_loader_array_simple)
     ASSERT_EQ(true, std::experimental::any_cast<bool>(bool_array[2]));
 }
 
+// Test for dot validation - prevents keys with dots in JSON
+TEST(config, json_loader_rejects_keys_with_dots)
+{
+    // Test Method A from the ticket - should be rejected
+    conf_file_writer json_config(R"({
+        "core": {
+            "resources.memory_limit": "50GB"
+        }
+    })");
+
+    json_loader loader(json_config.get());
+    ASSERT_THROW(loader.load_all(), xlio_exception);
+}
+
+// Test that proper nested structure (Method B) still works
+TEST(config, json_loader_accepts_proper_nested_structure)
+{
+    // Test Method B from the ticket - should work correctly
+    conf_file_writer json_config(R"({
+        "core": {
+            "resources": {
+                "memory_limit": "50GB"
+            }
+        }
+    })");
+
+    json_loader loader(json_config.get());
+    std::map<std::string, std::experimental::any> data = loader.load_all();
+
+    ASSERT_EQ("50GB",
+              std::experimental::any_cast<std::string>(data["core.resources.memory_limit"]));
+}
+
+// Test various edge cases for dot validation
+TEST(config, json_loader_dot_validation_edge_cases)
+{
+    // Test key with multiple dots
+    {
+        conf_file_writer json_config(R"({
+            "core": {
+                "a.b.c": "value"
+            }
+        })");
+        json_loader loader(json_config.get());
+        ASSERT_THROW(loader.load_all(), xlio_exception);
+    }
+
+    // Test key starting with dot
+    {
+        conf_file_writer json_config(R"({
+            "core": {
+                ".hidden": "value"
+            }
+        })");
+        json_loader loader(json_config.get());
+        ASSERT_THROW(loader.load_all(), xlio_exception);
+    }
+
+    // Test key ending with dot
+    {
+        conf_file_writer json_config(R"({
+            "core": {
+                "suffix.": "value"
+            }
+        })");
+        json_loader loader(json_config.get());
+        ASSERT_THROW(loader.load_all(), xlio_exception);
+    }
+
+    // Test key with only dots
+    {
+        conf_file_writer json_config(R"({
+            "core": {
+                "...": "value"
+            }
+        })");
+        json_loader loader(json_config.get());
+        ASSERT_THROW(loader.load_all(), xlio_exception);
+    }
+}
+
+// Test that valid keys without dots still work
+TEST(config, json_loader_valid_keys_without_dots)
+{
+    conf_file_writer json_config(R"({
+        "core": {
+            "log_level": 2,
+            "memory_limit": "1GB",
+            "enable_feature": true,
+            "nested": {
+                "value": "test"
+            }
+        }
+    })");
+
+    json_loader loader(json_config.get());
+    std::map<std::string, std::experimental::any> data = loader.load_all();
+
+    ASSERT_EQ(2, std::experimental::any_cast<int64_t>(data["core.log_level"]));
+    ASSERT_EQ("1GB", std::experimental::any_cast<std::string>(data["core.memory_limit"]));
+    ASSERT_EQ(true, std::experimental::any_cast<bool>(data["core.enable_feature"]));
+    ASSERT_EQ("test", std::experimental::any_cast<std::string>(data["core.nested.value"]));
+}
+
 TEST(config, json_loader_array_of_objects)
 {
     conf_file_writer json_config(R"({