simple injection test passing

Author: danielepanozzo

.vscode/launch.json

@@ -6,7 +6,7 @@
         "type": "cppdbg",
         "request": "launch",
         "program": "/home/daniele/git/simple-json-validator/build/tests/unit_tests",
-        "args": ["type_string"],
+        "args": ["simple"],
         "stopAtEntry": false,
         "cwd": "/home/daniele/git/simple-json-validator/build/",
         "environment": [],

src/sjv/sjv.cpp

@@ -35,10 +35,14 @@ namespace sjv
             for (auto e : flat.items())
             {
                 // If the pointer matches a strict subset of it, add it to the flattened
-                std::tuple<bool, string> subset = is_subset_pointer(string(rule["pointer"]), e.key());
+                std::tuple<bool, string> subset = is_subset_pointer(e.key(), string(rule["pointer"]));
                 if (std::get<0>(subset))
                     out_flat[std::get<1>(subset)] = rule["default"];
             }
+            // Special case as "/" is not inserted in the flat representation
+            std::tuple<bool, string> subset = is_subset_pointer("/", string(rule["pointer"]));
+            if (std::get<0>(subset))
+                out_flat[std::get<1>(subset)] = rule["default"];
         }
 
         // Unflatten the input
@@ -76,6 +80,8 @@ namespace sjv
 
             if (strict)
                 return false;
+            else
+                return true;
         }
 
         // Test all rules, only one must pass, otherwise throw exception
@@ -85,7 +91,7 @@ namespace sjv
             if (verify_rule(input, i))
                 count++;
 
-        if (count == 0 && !matching_rules.empty())
+        if (count == 0 && !matching_rules.empty()) 
         {
             // Before giving up, try boxing a primitive type
             if (boxing_primitive && !input.is_array())
@@ -383,7 +389,7 @@ namespace sjv
 
     std::tuple<bool, string> SJV::is_subset_pointer(const string &json, const string &pointer)
     {
-
+        std::cout << "is_subset_pointer(" << json << "," << pointer << ")" << std::endl;
         // Splits a string into tokens using the deliminator delim
         auto tokenize = [](std::string const &str, const char delim) {
             size_t start;
@@ -427,25 +433,31 @@ namespace sjv
             || (pointer_t.size() == 0))
             return {false, ""};
 
-        std::string buf = "/";
+        std::string buf = "";
         // if it is shorter, match every entry
         for (unsigned i = 0; i < pointer_t.size(); ++i)
         {
             // if there is no corresponding entry on json, copy and move on
-            if (json_t.size() < i)
-                buf.append(replace_all(pointer_t[i], "*", "0") + "/");
-
+            if (json_t.size() <= i)
+            {
+                buf.append("/" + replace_all(pointer_t[i], "*", "0"));
+            }
             // if there is an entry on json and it is the same, move on
-            if (json_t[i] == pointer_t[i])
-                buf.append(pointer_t[i] + "/");
-
+            else if (json_t[i] == pointer_t[i])
+            {
+                buf.append("/" + pointer_t[i]);
+            }
             // if the pointer contains a star, then accept any integer on json
-            if (pointer_t[i] == "*")
+            else if (pointer_t[i] == "*")
+            {
                 if (is_number(json_t[i]))
-                    buf.append(json_t[i] + "/");
-
+                    buf.append("/" + json_t[i]);
+            }
             // if no rule matches it is not a match
-            return {false, ""};
+            else
+            {
+                return {false, ""};
+            }
         }
 
         return {true, buf};

tests/test_validator.cpp

@@ -236,3 +236,96 @@ TEST_CASE("file_01", "[validator]")
     INFO(s);
     REQUIRE(r);
 }
+
+TEST_CASE("simple", "[inject]")
+{
+    json input = R"( 
+        {
+            "string1": "teststring",
+            "geometry": 
+            {
+                "nested": 3
+            }
+        }
+        )"_json;
+
+    json rules = R"( 
+        [
+        {
+            "pointer": "/",
+            "type": "object",
+            "required": ["string1"],
+            "optional":["geometry","other"]
+        },
+        {
+            "pointer": "/geometry",
+            "type": "object",
+            "default": null,
+            "optional": ["nested"]
+        },
+        {
+            "pointer": "/geometry/nested",
+            "type": "int",
+            "default": 3
+        },
+        {
+            "pointer": "/other",
+            "type": "int",
+            "default": null
+        },
+        {
+            "pointer": "/other/nested",
+            "type": "int",
+            "default": 3
+        }
+        ]
+        )"_json;
+
+    json output = R"( 
+        {
+            "string1": "teststring",
+            "geometry": 
+            {
+                "nested": 3
+            },
+            "other": 
+            {
+                "nested": 3
+            }
+        }
+        )"_json;
+
+    sjv::SJV sjv;
+
+    sjv.strict = false;
+
+    bool r = sjv.verify_json(input,rules); 
+    std:: string s = sjv.log2str();
+    INFO(s);
+    REQUIRE(r);
+
+    json return_json = sjv.inject_defaults(input,rules); 
+
+    std::cout << return_json << std::endl; 
+
+    INFO(return_json);
+    REQUIRE(return_json == output);
+}
+
+// TEST_CASE("file_inject", "[inject]")
+// {
+//     std::ifstream ifs1("../data/input_01.json");
+//     json input = json::parse(ifs1);
+
+//     std::ifstream ifs2("../data/rules_01.json");
+//     json rules = json::parse(ifs2);
+
+//     sjv::SJV sjv;
+
+//     sjv.strict = true;
+
+//     bool r = sjv.verify_json(input,rules); 
+//     std:: string s = sjv.log2str();
+//     INFO(s);
+//     REQUIRE(r);
+// }