--- /dev/null
+/*
+==================================================================================
+
+ Copyright (c) 2018-2019 AT&T Intellectual Property.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+==================================================================================
+*/
+
+/* Author : Ashwin Sridharan
+ Date : Sept 2019
+*/
+
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+#include <json_handler.hpp>
+
+void gen_message(std::string & message_string, bool enforce, int blocking_rate, int trigger_threshold, int window_length){
+ std::string enforce_string ((enforce? "true":"false"));
+ message_string = "{\"enforce\":" + enforce_string + ",";
+ message_string += std::string("\"blocking_rate\":") + std::to_string(blocking_rate) + ",";
+ message_string += std::string("\"window_length\":") + std::to_string(window_length) + ",";
+ message_string += std::string("\"trigger_threshold\":") + std::to_string(trigger_threshold) + "}";
+}
+
+
+TEST_CASE("JSON-schema", "Schema Check"){
+ jsonHandler json_test;
+ std::vector<TrieNode> schema_path;
+ TrieNode * test_node;
+ std::string valid_schema_file = "../schemas/adm-ctrl-xapp-policy-schema.json";
+ std::string valid_sample_file = "../schemas/sample.json";
+ std::string response;
+
+
+ SECTION("Invalid Schema File"){
+ REQUIRE_THROWS( json_test.load_schema("hello there"));
+ REQUIRE_THROWS( json_test.load_schema("hello there", NULL));
+ REQUIRE_THROWS( json_test.load_schema("hello there", test_node));
+ }
+
+
+ SECTION("Invalid JSON"){
+ REQUIRE_THROWS( json_test.load_schema("invalid_json.txt"));
+ REQUIRE_THROWS( json_test.load_schema("invalid_json.txt", NULL));
+ REQUIRE_THROWS( json_test.load_schema("invalid_json.txt", test_node));
+
+
+ }
+
+ // SECTION("Valid File and JSON"){
+ // bool res = json_test.load_schema(valid_schema_file);
+ // REQUIRE(res == TRUE);
+ // }
+
+ SECTION("Valid File and JSON, invalid schema root "){
+ schema_path.clear();
+ schema_path.emplace_back("controlS");
+ schema_path.emplace_back((int)0);
+ schema_path.emplace_back("message_receives_payload_schema");
+ schema_path[0].add_child(&schema_path[1]);
+ schema_path[1].add_child(&schema_path[2]);
+
+ REQUIRE_THROWS(json_test.load_schema(valid_schema_file, &schema_path[0]));
+ }
+
+ SECTION("Valid File and JSON & root"){
+ schema_path.clear();
+ schema_path.emplace_back("controls");
+ schema_path.emplace_back((int)0);
+ schema_path.emplace_back("message_receives_payload_schema");
+ schema_path[0].add_child(&schema_path[1]);
+ schema_path[1].add_child(&schema_path[2]);
+ std::string message_string;
+ bool res;
+
+ json_test.load_schema(valid_schema_file, &schema_path[0]);
+
+ gen_message(message_string, 0, 10, 20, 30);
+ res = json_test.is_valid(message_string.c_str(), message_string.length(), response);
+ REQUIRE(res == true);
+
+ gen_message(message_string, 0, 10, -5, 30);
+ res = json_test.is_valid(message_string.c_str(), message_string.length(), response);
+ REQUIRE(res == false);
+
+ gen_message(message_string, 0, 120, 10, 5);
+ res = json_test.is_valid(message_string.c_str(), message_string.length(), response);
+ REQUIRE(res == false);
+
+ gen_message(message_string, 0, 20, 10, 5);
+ message_string = message_string + "}";
+ res = json_test.is_valid(message_string.c_str(), message_string.length(), response);
+ REQUIRE(res == false);
+
+ }
+
+
+}
+
+TEST_CASE("DataContainer", "Get/set"){
+ std::string test_string = "Hello there";
+ int test_int = 101;
+ double test_real = 123.8;
+ long int test_long = 2839289;
+ unsigned int test_uint = 189;
+ unsigned long test_ulong = 29392329;
+
+ SECTION("Validate data types"){
+ TrieNode test("Test Node");
+ test.set_value(test_string);
+ const DataContainer * val = test.get_value();
+ REQUIRE(val->tag == DataContainer::Types::str);
+ REQUIRE(val->value.s == test_string);
+
+ test.set_value(test_int);
+ val = test.get_value();
+ REQUIRE(val->tag == DataContainer::Types::integer);
+ REQUIRE(val->value.i == test_int);
+
+
+ test.set_value(test_uint);
+ val = test.get_value();
+ REQUIRE(val->tag == DataContainer::Types::uinteger);
+ REQUIRE(val->value.ui == test_uint);
+
+ test.set_value(test_real);
+ val = test.get_value();
+ REQUIRE(val->tag == DataContainer::Types::real);
+ REQUIRE(val->value.f == test_real);
+
+ test.set_value(test_long);
+ val = test.get_value();
+ REQUIRE(val->tag == DataContainer::Types::big_integer);
+ REQUIRE(val->value.l == test_long);
+
+
+ test.set_value(test_ulong);
+ val = test.get_value();
+ REQUIRE(val->tag == DataContainer::Types::ubig_integer);
+ REQUIRE(val->value.ul == test_ulong);
+
+ test.print_id();
+ test.print_value();
+
+ REQUIRE(test.is_child() == true);
+
+ TrieNode test_child("child");
+ test.add_child(&test_child);
+ REQUIRE(test.is_child() == false);
+
+ }
+
+}
+TEST_CASE("JSON-getset", "Get/Set values"){
+
+ jsonHandler json_test;
+ std::vector<TrieNode> schema_path;
+ std::vector<TrieNode> key_path;
+ TrieNode *test_node;
+ std::string valid_schema_file = "../schemas/adm-ctrl-xapp-policy-schema.json";
+ std::string valid_sample_file = "../schemas/samples.json";
+ std::string response;
+ bool res;
+
+ SECTION("Invalid buffer file"){
+ REQUIRE_THROWS( json_test.load_buffer("hello there"));
+ REQUIRE_THROWS( json_test.load_buffer("hello there", NULL));
+ REQUIRE_THROWS( json_test.load_buffer("hello there", test_node));
+ }
+
+ SECTION("Validate buffer"){
+ schema_path.clear();
+ schema_path.emplace_back("controls");
+ schema_path.emplace_back((int)0);
+ schema_path.emplace_back("message_receives_payload_schema");
+ schema_path[0].add_child(&schema_path[1]);
+ schema_path[1].add_child(&schema_path[2]);
+ json_test.load_schema(valid_schema_file, &schema_path[0]);
+
+ schema_path.clear();
+ schema_path.emplace_back("message_receives_example");
+ json_test.load_buffer(valid_sample_file, &schema_path[0]);
+
+ std::string buffer = json_test.get_buffer();
+ res = json_test.is_valid(buffer.c_str(), buffer.length(), response);
+ REQUIRE(res == true);
+ }
+
+ SECTION("Get correct value from internal buffer"){
+ int res;
+ std::string message_string;
+ std::vector<TrieNode *> available_keys;
+ TrieNode test("window_length");
+ TrieNode invalid_test("Window_length");
+
+ // Try with no buffer loaded
+ res = json_test.get_values(response, &test, available_keys);
+ REQUIRE(res == -4);
+
+ // Try with buffer loaded
+ schema_path.clear();
+ schema_path.emplace_back("message_receives_example");
+ json_test.load_buffer(valid_sample_file, &schema_path[0]);
+
+ available_keys.clear();
+ res = json_test.get_values(response, &test, available_keys);
+ REQUIRE (res == 1);
+ REQUIRE(available_keys.size() == 1);
+ REQUIRE(available_keys[0]->get_value()->value.i == 10);
+
+ available_keys.clear();
+ res = json_test.get_values(response, &invalid_test, available_keys);
+ REQUIRE (res == 0);
+ REQUIRE(available_keys.size() == 0);
+
+
+ }
+ SECTION("Get values from supplied buffer"){
+ int res;
+ std::string message_string;
+ std::vector<TrieNode *> available_keys;
+
+
+ bool enforce = true;
+ int blocking_rate = 10;
+ int trigger_threshold = 5000;
+ int window_length = 25;
+
+ TrieNode test("window_length");
+ available_keys.clear();
+ gen_message(message_string, enforce, blocking_rate, trigger_threshold, window_length);
+ res = json_test.get_values(message_string.c_str(), message_string.length(), response, &test, available_keys);
+ REQUIRE(res == 0);
+ REQUIRE(available_keys.size() == 1);
+ REQUIRE(available_keys[0]->get_value()->value.i == 25);
+
+ TrieNode invalid_test("Window_length");
+ available_keys.clear();
+ gen_message(message_string, enforce, blocking_rate, trigger_threshold, window_length);
+ res = json_test.get_values(message_string.c_str(), message_string.length(), response, &invalid_test, available_keys);
+ REQUIRE(res == -3);
+ REQUIRE(available_keys.size() == 0);
+
+
+ }
+
+
+ SECTION("Get/Set from memory"){
+ int res;
+ std::vector<TrieNode *> keys;
+
+ TrieNode test1("blocking_rate");
+ int blocking_rate = 23;
+ test1.set_value(blocking_rate);
+
+ TrieNode test2("window_length");
+ int window_length = 45;
+ test2.set_value(window_length);
+
+ schema_path.clear();
+ schema_path.emplace_back("message_receives_example");
+ json_test.load_buffer(valid_sample_file, &schema_path[0]);
+
+ keys.clear();
+ keys.push_back(&test1);
+ keys.push_back(&test2);
+ res = json_test.set_values(response, keys);
+ REQUIRE(res == 0);
+
+ keys.clear();
+ std::string message_string(response);
+ res = json_test.get_values(message_string.c_str(), message_string.length(), response, &test1, keys);
+ REQUIRE(res == 0);
+ REQUIRE(keys.size() == 1);
+ REQUIRE(keys[0]->get_value()->value.i == blocking_rate);
+
+ keys.clear();
+ res = json_test.get_values(message_string.c_str(), message_string.length(), response, &test2, keys);
+ REQUIRE(res == 0);
+ REQUIRE(keys.size() == 1);
+ REQUIRE(keys[0]->get_value()->value.i == window_length);
+
+ }
+
+
+ SECTION("Get/Set from buffer "){
+ int res;
+ std::vector<TrieNode *> keys;
+ std::string message_string;
+
+ bool enforce = true;
+ int blocking_rate = 10;
+ int trigger_threshold = 5000;
+ int window_length = 25;
+
+ gen_message(message_string, enforce, blocking_rate, trigger_threshold, window_length);
+
+ TrieNode test_node("blocking_rate");
+ blocking_rate = 33;
+ test_node.set_value(blocking_rate);
+
+
+ keys.clear();
+ keys.push_back(&test_node);
+ res = json_test.set_values(message_string.c_str(), message_string.length(), response, keys);
+ REQUIRE(res == 0);
+
+ keys.clear();
+ message_string = response;
+ res = json_test.get_values(message_string.c_str(), message_string.length(), response, &test_node, keys);
+ REQUIRE(res == 0);
+ REQUIRE(keys.size() == 1);
+ REQUIRE(keys[0]->get_value()->value.i == blocking_rate);
+
+ }
+
+
+ SECTION("multi-level get/set"){
+ std::vector<TrieNode *> keys;
+ schema_path.clear();
+ schema_path.emplace_back("test1");
+ schema_path.emplace_back(1);
+ schema_path[0].add_child(&schema_path[1]);
+
+ std::string sample_file = "test-data/test_sample.json";
+ REQUIRE_THROWS(json_test.load_buffer(sample_file, &schema_path[0]));
+
+ schema_path.clear();
+ schema_path.emplace_back("test1");
+ schema_path.emplace_back(1);
+ schema_path.emplace_back("test4");
+ schema_path[0].add_child(&schema_path[1]);
+ schema_path[1].add_child(&schema_path[2]);
+
+ json_test.load_buffer(sample_file, &schema_path[0]);
+ std::string buffer = json_test.get_buffer();
+
+ TrieNode test("test5");
+ keys.clear();
+ res = json_test.get_values(response, &test, keys);
+ REQUIRE(res == 1);
+ REQUIRE(keys.size() == 1);
+ REQUIRE(keys[0]->get_value()->value.s == "new target");
+ }
+
+}
+
+
+
+
Code Review / ric-app / admin.git / blobdiff