Add format subcommand to regression_test

Author: hnakamur

test/common/modsecurity_test.cc

@@ -68,18 +68,25 @@ bool ModSecurityTest<T>::load_test_json(const std::string &file) {
         return false;
     }
 
-    size_t num_tests = node->u.array.len;
-    for ( int i = 0; i < num_tests; i++ ) {
-        yajl_val obj = node->u.array.values[i];
-
-        auto u = std::unique_ptr<T>(T::from_yajl_node(obj));
+    if (m_format) {
+        auto u = std::unique_ptr<T>(T::from_yajl_node(node));
         u->filename = file;
 
-        const auto key = u->filename + ":" + u->name;
-        (*this)[key].push_back(std::move(u));
-    }
+        (*this)[file].push_back(std::move(u));
+    } else {
+        size_t num_tests = node->u.array.len;
+        for ( int i = 0; i < num_tests; i++ ) {
+            yajl_val obj = node->u.array.values[i];
 
-    yajl_tree_free(node);
+            auto u = std::unique_ptr<T>(T::from_yajl_node(obj));
+            u->filename = file;
+
+            const auto key = u->filename + ":" + u->name;
+            (*this)[key].push_back(std::move(u));
+        }
+
+        yajl_tree_free(node);
+    }
 
     return true;
 }
@@ -140,6 +147,10 @@ void ModSecurityTest<T>::cmd_options(int argc, char **argv) {
         i++;
         m_test_multithreaded = true;
     }
+    if (argc > i && strcmp(argv[i], "format") == 0) {
+        i++;
+        m_format = true;
+    }
     if (std::getenv("AUTOMAKE_TESTS")) {
         m_automake_output = true;
     }

test/common/modsecurity_test.h

@@ -35,7 +35,8 @@ template <class T> class ModSecurityTest :
         : m_test_number(0),
         m_automake_output(false),
         m_count_all(false),
-        m_test_multithreaded(false) { }
+        m_test_multithreaded(false),
+        m_format{false} { }
 
     std::string header();
     void cmd_options(int, char **);
@@ -50,6 +51,7 @@ template <class T> class ModSecurityTest :
     bool m_automake_output;
     bool m_count_all;
     bool m_test_multithreaded;
+    bool m_format;
 };
 
 }  // namespace modsecurity_test

test/regression/regression.cc

@@ -41,6 +41,7 @@ using modsecurity_test::CustomDebugLog;
 using modsecurity_test::ModSecurityTest;
 using modsecurity_test::ModSecurityTestResults;
 using modsecurity_test::RegressionTest;
+using modsecurity_test::RegressionTests;
 using modsecurity_test::RegressionTestResult;
 
 using modsecurity::Utils::regex_search;
@@ -436,6 +437,32 @@ int main(int argc, char **argv)
     return 0;
 #else
     test.cmd_options(argc, argv);
+
+    if (test.m_format) {
+#ifdef WITH_YAJL
+        std::cout << "start formatting test case JSON files" << std::endl;
+        ModSecurityTest<RegressionTests> test;
+        test.cmd_options(argc, argv);
+        test.load_tests();
+        for (const auto &[name, tests] : test) {
+            std::ofstream ofs{name};
+            if (!ofs.is_open()) {
+                std::cerr << "cannot open " << name << " for writing." << std::endl;
+                return 1;
+            }
+            ofs << tests[0]->toJSON();
+            ofs.close();
+            std::cout << "written formatted JSON to " << name << std::endl;
+        }
+        std::cout << "finished formatting files." << std::endl;
+        return 0;
+#else
+        std::cout << "Test utility cannot format test case JSON files without being built with YAJL." \
+            << std::endl;
+        return 1;
+#endif
+    }
+
     if (!test.m_automake_output && !test.m_count_all) {
         std::cout << test.header();
     }

test/regression/regression_test.cc

@@ -21,6 +21,10 @@
 #include <unordered_map>
 #include <string>
 
+#ifdef WITH_YAJL
+#include <yajl/yajl_gen.h>
+#endif
+
 namespace modsecurity_test {
 
 std::string RegressionTest::print() {
@@ -218,4 +222,235 @@ RegressionTest *RegressionTest::from_yajl_node(const yajl_val &node) {
     return u;
 }
 
+RegressionTests *RegressionTests::from_yajl_node(const yajl_val &node) {
+    RegressionTests *u = new RegressionTests(node);
+    size_t num_tests = node->u.array.len;
+    for ( int i = 0; i < num_tests; i++ ) {
+        yajl_val obj = node->u.array.values[i];
+        u->tests.emplace_back(*RegressionTest::from_yajl_node(obj));
+    }
+    return u;
+}
+
+RegressionTests::~RegressionTests() {
+#ifdef WITH_YAJL
+    yajl_tree_free(node);
+#endif
+}
+
+#ifdef WITH_YAJL
+
+static yajl_gen_status jayl_gen_string_view(yajl_gen g, std::string_view s) {
+    return yajl_gen_string(g, reinterpret_cast<const unsigned char *>(s.data()), s.length());
+}
+
+static yajl_gen_status jayl_gen_key_val(yajl_gen g, std::string_view key, std::string_view val) {
+    auto s = jayl_gen_string_view(g, key);
+    if (s != yajl_gen_status_ok) {
+        return s;
+    }
+    return jayl_gen_string_view(g, val);
+}
+
+static yajl_gen_status copy_number(yajl_gen g, std::string_view key, yajl_val val) {
+    if (!YAJL_IS_NUMBER(val)) {
+        std::cerr << "error: " << key << " must be number.\n";
+        exit(1);
+    }
+    auto s = jayl_gen_string_view(g, key);
+    if (s != yajl_gen_status_ok) {
+        return s;
+    }
+    return yajl_gen_number(g,
+        reinterpret_cast<const char *>(val->u.number.r),
+        strlen(val->u.number.r));
+}
+
+static yajl_gen_status copy_string(yajl_gen g, std::string_view key, yajl_val val) {
+    if (!YAJL_IS_STRING(val)) {
+        std::cerr << "error: " << key << " must be string.\n";
+        exit(1);
+    }
+    return jayl_gen_key_val(g, key, val->u.string);
+}
+
+static void ensure_obj(std::string_view key, yajl_val obj) {
+    if (!YAJL_IS_OBJECT(obj)) {
+        std::cerr << "error: " << key << " must be object.\n";
+        exit(1);
+    }
+}
+
+static void copy_str_map(yajl_gen g, std::string_view key, yajl_val val) {
+    if (!YAJL_IS_OBJECT(val)) {
+        std::cerr << "error: " << key << " must be object.\n";
+        exit(1);
+    }
+    jayl_gen_string_view(g, key);
+    yajl_gen_map_open(g);
+    for (size_t i = 0; i < val->u.object.len; ++i) {
+        const char *key2 = val->u.object.keys[i];
+        yajl_val val2 = val->u.object.values[i];
+        copy_string(g, key2, val2);
+    }
+    yajl_gen_map_close(g);
+}
+
+static void copy_str_array(yajl_gen g, std::string_view key, yajl_val val) {
+    if (!YAJL_IS_ARRAY(val)) {
+        std::cerr << "error: " << key << " must be array.\n";
+        exit(1);
+    }
+    jayl_gen_string_view(g, key);
+    yajl_gen_array_open(g);
+    for (size_t i = 0; i < val->u.array.len; ++i) {
+        yajl_val val2 = val->u.array.values[i];
+        if (!YAJL_IS_STRING(val2)) {
+            std::cerr << "error: array element of " << key << " must be string.\n";
+            exit(1);
+        }
+        jayl_gen_string_view(g, val2->u.string);
+    }
+    yajl_gen_array_close(g);
+}
+
+static void copy_body(yajl_gen g, std::string_view key, yajl_val val) {
+    if (YAJL_IS_STRING(val)) {
+        jayl_gen_key_val(g, key, val->u.string);
+    } else {
+        copy_str_array(g, key, val);
+    }
+}
+
+std::string RegressionTests::toJSON() {
+    const unsigned char *buf;
+    size_t len;
+    yajl_gen g;
+
+    g = yajl_gen_alloc(NULL);
+    if (g == NULL) {
+        return "";
+    }
+    yajl_gen_config(g, yajl_gen_beautify, 1);
+
+    if (!YAJL_IS_ARRAY(node)) {
+        std::cerr << "error: toplevel must be array.\n";
+        exit(1);
+    }
+
+    yajl_gen_array_open(g);
+    for (size_t i = 0; i < node->u.array.len; ++i) {
+        yajl_val test_obj = node->u.array.values[i];
+        ensure_obj("test", test_obj);
+        yajl_gen_map_open(g);
+        for (size_t j = 0; j < test_obj->u.object.len; ++j) {
+            const char *key = test_obj->u.object.keys[j];
+            yajl_val val = test_obj->u.object.values[j];
+            if (strcmp(key, "enabled") == 0
+                || strcmp(key, "version_min") == 0
+                || strcmp(key, "version_max") == 0
+                || strcmp(key, "github_issue") == 0) {
+                copy_number(g, key, val);
+            } else if (strcmp(key, "title") == 0
+                || strcmp(key, "url") == 0
+                || strcmp(key, "resource") == 0) {
+                copy_string(g, key, val);
+            } else if (strcmp(key, "client") == 0) {
+                ensure_obj("client", val);
+                jayl_gen_string_view(g, "client");
+                yajl_gen_map_open(g);
+                for (size_t k = 0; k < val->u.object.len; ++k) {
+                    const char *key2 = val->u.object.keys[k];
+                    yajl_val val2 = val->u.object.values[k];
+                    if (strcmp(key2, "ip") == 0) {
+                        copy_string(g, key2, val2);
+                    } else if (strcmp(key2, "port") == 0) {
+                        copy_number(g, key2, val2);
+                    }
+                }
+                yajl_gen_map_close(g);
+            } else if (strcmp(key, "server") == 0) {
+                ensure_obj("server", val);
+                jayl_gen_string_view(g, "server");
+                yajl_gen_map_open(g);
+                for (size_t k = 0; k < val->u.object.len; ++k) {
+                    const char *key2 = val->u.object.keys[k];
+                    yajl_val val2 = val->u.object.values[k];
+                    if (strcmp(key2, "ip") == 0
+                        || strcmp(key2, "hostname") == 0) {
+                        copy_string(g, key2, val2);
+                    } else if (strcmp(key2, "port") == 0) {
+                        copy_number(g, key2, val2);
+                    }
+                }
+                yajl_gen_map_close(g);
+            } else if (strcmp(key, "request") == 0) {
+                ensure_obj("request", val);
+                jayl_gen_string_view(g, "request");
+                yajl_gen_map_open(g);
+                for (size_t k = 0; k < val->u.object.len; ++k) {
+                    const char *key2 = val->u.object.keys[k];
+                    yajl_val val2 = val->u.object.values[k];
+                    if (strcmp(key2, "url") == 0
+                        || strcmp(key2, "method") == 0) {
+                        copy_string(g, key2, val2);
+                    } else if (strcmp(key2, "http_version") == 0) {
+                        copy_number(g, key2, val2);
+                    } else if (strcmp(key2, "headers") == 0) {
+                        copy_str_map(g, key2, val2);
+                    } else if (strcmp(key2, "body") == 0) {
+                        copy_body(g, key2, val2);
+                    }
+                }
+                yajl_gen_map_close(g);
+            } else if (strcmp(key, "response") == 0) {
+                ensure_obj("response", val);
+                jayl_gen_string_view(g, "response");
+                yajl_gen_map_open(g);
+                for (size_t k = 0; k < val->u.object.len; ++k) {
+                    const char *key2 = val->u.object.keys[k];
+                    yajl_val val2 = val->u.object.values[k];
+                    if (strcmp(key2, "protocol") == 0) {
+                        copy_string(g, key2, val2);
+                    } else if (strcmp(key2, "headers") == 0) {
+                        copy_str_map(g, key2, val2);
+                    } else if (strcmp(key2, "body") == 0) {
+                        copy_body(g, key2, val2);
+                    }
+                }
+                yajl_gen_map_close(g);
+            } else if (strcmp(key, "expected") == 0) {
+                ensure_obj("expected", val);
+                jayl_gen_string_view(g, "expected");
+                yajl_gen_map_open(g);
+                for (size_t k = 0; k < val->u.object.len; ++k) {
+                    const char *key2 = val->u.object.keys[k];
+                    yajl_val val2 = val->u.object.values[k];
+                    if (strcmp(key2, "audit_log") == 0
+                        || strcmp(key2, "debug_log") == 0
+                        || strcmp(key2, "error_log") == 0
+                        || strcmp(key2, "redirect_url") == 0
+                        || strcmp(key2, "parser_error") == 0) {
+                        copy_string(g, key2, val2);
+                    } else if (strcmp(key2, "http_code") == 0) {
+                        copy_number(g, key2, val2);
+                    }
+                }
+                yajl_gen_map_close(g);
+            } else if (strcmp(key, "rules") == 0) {
+                copy_str_array(g, key, val);
+            }
+        }
+        yajl_gen_map_close(g);
+    }
+    yajl_gen_array_close(g);
+
+    yajl_gen_get_buf(g, &buf, &len);
+    std::string s{reinterpret_cast<const char*>(buf), len};
+    yajl_gen_free(g);
+    return s;
+}
+
+#endif // WITH_YAJL
+
 }  // namespace modsecurity_test

test/regression/regression_test.h

@@ -78,6 +78,19 @@ class RegressionTest {
     std::string redirect_url;
 };
 
+class RegressionTests {
+ public:
+    RegressionTests(const yajl_val &node) : node{node} {}
+    ~RegressionTests();
+    static RegressionTests *from_yajl_node(const yajl_val &);
+    std::string toJSON();
+
+    std::string filename;
+    std::string name;
+
+    std::vector<RegressionTest> tests;
+    const yajl_val node;
+};
 
 class RegressionTestResult {
  public: