使用C++11动态解析json并使用DataFrame进行结果对

本例特点，

1. 使用Debug::DeathHandler类来进行异常trace打印。
   注意Google GTest框架默认会捕获所有异常，导致C++的SIG_TERM信号无法被捕捉。
   所以需要设置环境变量 ENV GTEST_CATCH_EXCEPTIONS 0
   2.使用nlohmann::json做中间字典转换。类似一个python的万能dict类型。 nlohmann::json本身做了类型擦除，可以存储任意类型的变量。
   3.使用hosseinmoein DataFrame进行数据比对，得出结果。
   整体思路和Python类似。
   有了Debug::DeathHandler以后，效率大幅提升，类似不需要打断点了，几乎一看就知道什么异常。
   程序目录如下，

   
   image.png

代码如下，
CMakeLists.txt

cmake_minimum_required(VERSION 2.6)

if(APPLE)
    message(STATUS "This is Apple, do nothing.")
elseif(UNIX)
    message(STATUS "This is linux, set CMAKE_PREFIX_PATH.")
    set(CMAKE_PREFIX_PATH /vcpkg/ports/cppwork/vcpkg_installed/x64-linux/share)
endif(APPLE)

project(app_perf_test)

add_definitions(-std=c++17)
add_definitions(-g)

find_package(ZLIB)

find_package(glog REQUIRED)

find_package(OpenCV REQUIRED )

find_package(Boost REQUIRED COMPONENTS
    system
    filesystem
    serialization
    program_options
    thread
    )

find_package(DataFrame REQUIRED)

if(APPLE)
    MESSAGE(STATUS "This is APPLE, set INCLUDE_DIRS")
set(INCLUDE_DIRS ${Boost_INCLUDE_DIRS} /usr/local/include /usr/local/iODBC/include /opt/snowflake/snowflakeodbc/include/ ${CMAKE_CURRENT_SOURCE_DIR}/../../)
elseif(UNIX)
    MESSAGE(STATUS "This is linux, set INCLUDE_DIRS")
    set(INCLUDE_DIRS ${Boost_INCLUDE_DIRS} /usr/local/include ${CMAKE_CURRENT_SOURCE_DIR}/../../)
endif(APPLE)


if(APPLE)
    MESSAGE(STATUS "This is APPLE, set LINK_DIRS")
    set(LINK_DIRS /usr/local/lib /usr/local/iODBC/lib /opt/snowflake/snowflakeodbc/lib/universal)
elseif(UNIX)
    MESSAGE(STATUS "This is linux, set LINK_DIRS")
    set(LINK_DIRS ${Boost_INCLUDE_DIRS} /usr/local/lib /vcpkg/ports/cppwork/vcpkg_installed/x64-linux/lib)
endif(APPLE)

if(APPLE)
    MESSAGE(STATUS "This is APPLE, set ODBC_LIBS")
    set(ODBC_LIBS iodbc iodbcinst)
elseif(UNIX)
    MESSAGE(STATUS "This is linux, set LINK_DIRS")
    set(ODBC_LIBS odbc odbcinst ltdl)
endif(APPLE)

include_directories(${INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRS})


file( GLOB APP_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../utils/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../cases/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp  ${CMAKE_CURRENT_SOURCE_DIR}/../../http/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../yaml/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../df/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../death_handler/impl/*.cpp)
foreach( sourcefile ${APP_SOURCES} )
        file(RELATIVE_PATH filename ${CMAKE_CURRENT_SOURCE_DIR} ${sourcefile})
    
        string(FIND "${filename}"  "test.cpp" "TEMP")
    if( NOT "${TEMP}" STREQUAL "-1" )
        string(REPLACE ".cpp" "" file ${filename})
        add_executable(${file}  ${APP_SOURCES})
        target_link_libraries(${file} ${Boost_LIBRARIES} ZLIB::ZLIB glog::glog DataFrame::DataFrame ${OpenCV_LIBS})
        target_link_libraries(${file}  ssl crypto libgtest.a pystring libyaml-cpp.a libgmock.a ${ODBC_LIBS} libnanodbc.a pthread dl backtrace)
    endif()
endforeach( sourcefile ${APP_SOURCES})

test_cfg.h

#ifndef _FREDRIC_TEST_CFG_H_
#define _FREDRIC_TEST_CFG_H_

#include <string>
#include <map>

extern std::string v2_query_path;
extern int max_compare_count;

extern std::string www_host;
extern std::string api_host;

extern std::string www_company_path;

extern std::map<std::string, std::string> www_headers;

extern std::map<std::string, std::string> api_headers;
extern bool use_file;

// App Performance related json files

extern std::string apps_meta_file;

extern std::string test_dim_parse_data_file;

#endif

utils/req.h

#ifndef _FREDRIC_REQ_H_
#define _FREDRIC_REQ_H_

#include <string>

struct Req {
    static std::string make_a_www_query(const std::string& path, const std::string& body);
    static std::string make_a_api_query(const std::string& path); 
};
#endif

utils/req.cpp

#include "api_accuracy/utils/req.h"
#include "http/http_util.h"
#include "api_accuracy/test_cfg.h"

#include <glog/logging.h>

std::string Req::make_a_www_query(const std::string& path, const std::string& body) {
    std::string www_res{};
    bool get_www_res = HttpUtil::post_and_get_str(www_host, path, www_headers, body, www_res);
    if(!get_www_res) {
        LOG(ERROR) << "Get WWW result failure" << "\n";
        return "";
    }
    return std::move(www_res);
}

std::string Req::make_a_api_query(const std::string& path) {
    std::string api_res{};
    bool get_api_res = HttpUtil::get_str(api_host, path, api_headers, api_res);
    if(!get_api_res) {
        LOG(ERROR) << "Get api result failure" << "\n";
        return "";
    }
    return std::move(api_res);
}

utils/io_util.h

#ifndef _FREDRIC_IO_UTIL_H_
#define _FREDRIC_IO_UTIL_H_

#include <string>

struct IOUtil {
    static std::string read_file(const std::string& file_name);
    static bool write_file(const std::string& file_name, const std::string& content);
};

#endif

utils/io_util.cpp

#include "api_accuracy/utils/io_util.h"

#include <glog/logging.h>
#include <fstream>

std::string IOUtil::read_file(const std::string& file_name)  {
        std::fstream fs{file_name};
        if(!fs.is_open()) {
            LOG(ERROR) << "Open file [" << file_name << "] failed" << "\n";
            return "";
        }
        std::stringstream ss {};
        ss << fs.rdbuf();
        return std::move(ss.str());
}

bool IOUtil::write_file(const std::string& file_name, const std::string& content) {
    std::fstream fs{file_name, std::ios::out | std::ios::trunc};
    if(!fs.is_open()) {
        LOG(ERROR) << "Open file [" << file_name << "] failed" << "\n";
        return false;
    }

    fs << content;
    fs.close();
    return true;
}

utils/funcs.h

#ifndef _FREDRIC_FUNCS_H_
#define _FREDRIC_FUNCS_H_

#include "json/json.hpp"

#include <vector>
#include <string>
#include <map>

using json = nlohmann::json;

std::vector<std::string> get_map_keys(const std::map<std::string, std::string>& field_mapping);
std::vector<std::string> get_map_values(const std::map<std::string, std::string>& field_mapping);
std::string read_query_file_and_replace_consts(const json& prod, const std::string& www_query_file_name);
json parse_dim_product_fields(const json& result_json, const std::vector<std::string>& dim_keys_);
json convert_dim_values_to_api_values(const json& values, const std::map<std::string, std::string>& api_dim_mapping);
bool find_diff_and_save_f(const json& values_, const json& act_www_values_, const std::string& api_data_field_name);
#endif

utils/funcs.cpp

#include "api_accuracy/utils/funcs.h"
#include "api_accuracy/utils/io_util.h"
#include "df/df.h"

#include <pystring/pystring.h>

#include <cstddef>
#include <algorithm>

std::vector<std::string> get_map_keys(const std::map<std::string, std::string>& field_mapping) {
    std::vector<std::string> keys{};
    std::for_each(field_mapping.begin(), field_mapping.end(), [&keys](const auto& item){
        keys.push_back(item.first);
    });
    return keys;
}

std::vector<std::string> get_map_values(const std::map<std::string, std::string>& field_mapping) {
    std::vector<std::string> values{};
    std::for_each(field_mapping.begin(), field_mapping.end(), [&values](const auto& item){
        values.push_back(item.second);
    });
    return values;
}


std::string read_query_file_and_replace_consts(const json& prod, const std::string& www_query_file_name) {
    auto product_id = prod["product_id"].get<int64_t>();
    auto market_code = prod["market_code"].get<std::string>();
    auto start_date = prod["start_date"].get<std::string>();
    auto end_date = prod["end_date"].get<std::string>();
    auto country_code = prod["countries"].get<std::string>();
    auto device_code = prod["devices"].get<std::string>();
    auto granularity = prod["granularity"].get<std::string>();

    auto file_content = IOUtil::read_file(www_query_file_name);

    file_content = pystring::replace(file_content, "${product_id}", std::to_string(product_id));
    file_content = pystring::replace(file_content, "${market_code}", market_code);
    file_content = pystring::replace(file_content, "${start_date}", start_date);
    file_content = pystring::replace(file_content, "${end_date}", end_date);
    std::vector<std::string> country_list{};
    pystring::split(country_code, country_list, ",");
    json country_js = country_list;
    file_content = pystring::replace(file_content, "${country_code}", country_js.dump());
    file_content = pystring::replace(file_content, "${granularity}", granularity);

    if(country_list[0] == "all_supported") {
        auto content_js = json::parse(file_content);
        content_js["filters"].erase("country_code");
        file_content = content_js.dump();
    }

    std::vector<std::string> device_list{};
    pystring::split(device_code, device_list, ",");
    if(device_list[0] != "all_supported") {
        auto content_js = json::parse(file_content);
        content_js["filters"]["device_code"] = {
            {"in", device_list}
        };
        file_content = content_js.dump();
    }

    return file_content;
}


json parse_dim_product_fields(const json& result_json, const std::vector<std::string>& dim_keys_) {
    json values;
    auto facets = result_json["data"]["facets"];
    auto dims = result_json["data"]["dimensions"];
    for(auto&& facet_: facets) {
        json value;
        for(auto&& dim_key_: dim_keys_) {
            if(dim_key_.find("/") == std::string::npos) {
                value[dim_key_] = facet_[dim_key_];
            } else {
                json tmp_val;
                std::string tmp_key = "";
                std::vector<std::string> one_dim_keys {};
                pystring::split(dim_key_, one_dim_keys, "/");
                for(int i=0; i<one_dim_keys.size(); ++i) {
                    if(i==0) {
                        tmp_key = one_dim_keys[0];
                        if(!facet_[tmp_key].is_null()) {
                            tmp_val = std::to_string(facet_[tmp_key].get<int64_t>());
                        }else {
                            break;
                        }
                    }else {
                        for(auto&& begin=dims.begin(), end = dims.end(); begin!=end; ++begin) {
                            auto in_dim_key = begin.key();
                            auto in_dim_val = begin.value();

                            if(one_dim_keys[i-1] == in_dim_key) {
                                for(auto&& ii_begin=in_dim_val.begin(), ii_end=in_dim_val.end(); ii_begin!=ii_end; ++ii_begin) {
                                    auto ii_dim_key = ii_begin.key();
                                    auto ii_dim_val = ii_begin.value();
                                    if(ii_dim_key == tmp_val.get<std::string>()) {
                                        if(i == (one_dim_keys.size() - 1)){
                                             tmp_val = ii_dim_val[one_dim_keys[i]];
                                        }else {
                                            if(!ii_dim_val[one_dim_keys[i]].is_null()) {
                                                tmp_val = std::to_string(ii_dim_val[one_dim_keys[i]].get<int64_t>());
                                            } else {
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                value[dim_key_] = tmp_val;
            }
        }
        values.emplace_back(std::move(value));
    }
    return std::move(values);
}

json convert_dim_values_to_api_values(const json& values, const std::map<std::string, std::string>& api_dim_mapping) {
    json new_values;
    for(auto&& value: values) {
        json new_value;
        for(auto&& api_dim_item: api_dim_mapping) {
            auto api_key = api_dim_item.first; 
            auto dim_key = api_dim_item.second;
            new_value[api_key] = value[dim_key];
        }
        new_values.emplace_back(std::move(new_value));
    }
    return std::move(new_values);
}

bool find_diff_and_save_f(const json& values_, const json& act_www_values_, const std::string& api_data_field_name) {
    std::vector<std::string> pri_keys_{};
    auto df1 = df_op::convert_json_to_df(values_, pri_keys_);
    auto df2 = df_op::convert_json_to_df(act_www_values_, pri_keys_);
    std::string res_csv_path = "../result/" + api_data_field_name + "_res.csv";
    if(values_.size() == 0 && act_www_values_.size() == 0) {
        return false;
    }else if(values_.size() == 0 && act_www_values_.size()!=0) {
        df_op::write_to_csv(df2, res_csv_path);
        return true;
    }else if(values_.size() != 0 && act_www_values_.size() == 0) {
        df_op::write_to_csv(df1, res_csv_path);
        return true;
    }else {
        auto df3 = df1.concat<decltype(df2), json>(df2, concat_policy::all_columns);
        std::vector<std::string> keys_{Keys};
        auto df4 = df_op::remove_duplicate(df3, keys_);
        auto df_rows = df4.shape().first;
        if(df_rows == 0) {
            return false;
        }

        df_op::write_to_csv(df3, res_csv_path);
        return true;
    }
}

utils/compare.h

#ifndef _FREDRIC_COMPARE_H_
#define _FREDRIC_COMPARE_H_

#include <json/json.hpp>

#include <map>
#include <string>

using json = nlohmann::json;

struct Compare {
    Compare(const json& app_perf_result);

    json get_api_products_fields(const std::map<std::string, std::string>& field_mapping);

    json get_www_product_fields(const json& prod, const std::string& www_request_file_name, const std::map<std::string, std::string>& field_mapping);

    bool compare_api_and_www_meta_equal(const std::map<std::string, std::string>& field_mappings, const std::string& www_query_file);

    json  app_perf_result_;
};
#endif

utils/compare.cpp

#include "api_accuracy/utils/compare.h"
#include "api_accuracy/utils/funcs.h"
#include "api_accuracy/utils/req.h"
#include "api_accuracy/test_cfg.h"

#include "glog/logging.h"

Compare::Compare(const json& app_perf_result) {
    app_perf_result_ = app_perf_result;
}


json Compare::get_api_products_fields(const std::map<std::string, std::string>& field_mapping) {
    auto start_date = app_perf_result_["start_date"];
    auto end_date = app_perf_result_["end_date"];
    auto countries = app_perf_result_["countries"];
    auto granularity = app_perf_result_["granularity"];
    auto devices = app_perf_result_["devices"];
    auto products = app_perf_result_["products"];
    auto api_fields = get_map_keys(field_mapping);

    json api_values {};
    for(auto&& product_: products) {
        json api_value {};
        auto product_id = product_["product_id"];
        auto market_code = product_["market_code"];
        json prod_{
            {"product_id", product_id},
            {"market_code", market_code},
            {"granularity", granularity},
            {"start_date", start_date},
            {"end_date", end_date},
            {"countries", countries},
            {"devices", devices}
        };
        api_value["product"] = prod_;
        json values {};
        json value {};
        for(auto api_field: api_fields) {
            value[api_field] = product_[api_field];
        }
        values.emplace_back(std::move(value));
        api_value["values"] = values;
        api_values.push_back(std::move(api_value));
    }
    return api_values;
}


json Compare::get_www_product_fields(const json& prod, const std::string& www_request_file_name, const std::map<std::string, std::string>& field_mapping) {
    auto dar_query_str = read_query_file_and_replace_consts(prod, www_request_file_name);
    LOG(ERROR) << dar_query_str << "\n";
    auto dar_query_res_str = Req::make_a_www_query(v2_query_path, dar_query_str);
    auto dar_query_res = json::parse(dar_query_res_str);
    auto field_values = get_map_values(field_mapping);
    auto www_query_tmp_res = parse_dim_product_fields(dar_query_res, field_values);
    auto www_query_res = convert_dim_values_to_api_values(www_query_tmp_res, field_mapping);

    return www_query_res;
}


bool Compare::compare_api_and_www_meta_equal(const std::map<std::string, std::string>& field_mappings, const std::string& www_query_file) {
    auto api_products_ = get_api_products_fields(field_mappings);
    bool is_value_equal = true;
    int i = 0;

    for(auto&& api_prod_: api_products_) {
        auto prod_ = api_prod_["product"];
        auto values_ = api_prod_["values"];
        ++i;
        // 对比前max_compare_count条，退出
        if(i > max_compare_count) {
                LOG(INFO) << "Hit " << max_compare_count << " records, return." << "\n";
                break;
        }
        
        auto www_values_ = get_www_product_fields(prod_, www_query_file, field_mappings);
        LOG(INFO) << values_.dump() << "\n";
        LOG(INFO) << www_values_.dump() << "\n";

        std::sort(values_.begin(), values_.end());
        std::sort(www_values_.begin(), www_values_.end());
        bool has_diff = find_diff_and_save_f(values_, www_values_, "www_meta_info");
        is_value_equal = !has_diff;
        if(!is_value_equal) {
            LOG(ERROR) << "API and www values are not equals\n";
            LOG(ERROR) << "API : www_meta_info\n"; 
            LOG(ERROR) << values_ << "\n";
            LOG(ERROR) << "WWW : www_meta_info\n";
            LOG(ERROR) << www_values_ << "\n";
            break;
        }
    }
    return is_value_equal;
}

utils/case.h

#ifndef _FREDRIC_CASE_H_
#define _FREDRIC_CASE_H_
#include <string>

struct Case {
    std::string name;
    std::string url;
    int expect_code;
};

#endif

utils/beans.h

#ifndef _FREDRIC_BEANS_H_
#define _FREDRIC_BEANS_H_

#include <map>
#include <string>

extern std::map<std::string, std::string> DimProductMapping;

#endif

utils/beans.cpp

#include "api_accuracy/utils/beans.h"

std::map<std::string, std::string> DimProductMapping {
    {"product_id", "product_id"},
    {"product_name", "name"},
    {"product_description", "description"},
    {"category_id", "category_id"},
    {"unified_product_id", "unified_product_id"},
    {"category_name", "category_id/name"},
    {"category_slug", "category_id/slug"},
    {"market_code", "market_code"},
    {"publisher_name", "publisher_id/name"},
    {"publisher_market", "publisher_id/market_code"},
    {"company_name", "publisher_id/company_id/name"},
    {"company_exchange", "publisher_id/company_id/exchange"},
    {"company_stock_symbol", "publisher_id/company_id/ticker_symbol"},
    {"company_website", "publisher_id/company_id/website"},
    {"company_is_public", "publisher_id/company_id/is_public_company"}
};

test/app_perf_test.cpp

#include "api_accuracy/cases/app_perf_cases.h"
#include "api_accuracy/test_cfg.h"
#include "api_accuracy/utils/req.h"
#include "api_accuracy/utils/io_util.h"
#include "api_accuracy/utils/funcs.h"
#include "api_accuracy/utils/beans.h"
#include "api_accuracy/utils/compare.h"

#include "pystring/pystring.h"
#include "json/json.hpp"
#include "death_handler/death_handler.h"

#include <glog/logging.h>
#include <boost/filesystem.hpp>


#include <gtest/gtest.h>


using json = nlohmann::json;

int main(int argc, char** argv) {
    FLAGS_log_dir = "./";
    FLAGS_alsologtostderr = true;

    Debug::DeathHandler dh;

    google::InitGoogleLogging("./logs.log");
    testing::InitGoogleTest(&argc, argv);
    int ret = RUN_ALL_TESTS();
    return ret;
}

class AppPerfTests: public testing::Test {
    protected:
    virtual void SetUp(){
        for(auto&& case_: app_perf_pos_cases) {
            auto case_name = case_.name;
            auto case_url = case_.url;

            if(!use_file) {
                auto case_result_ = Req::make_a_api_query(case_url);
                bool write_res = IOUtil::write_file(case_name, case_result_);
                if(!write_res) {
                    // Write case result failed
                    ASSERT_TRUE(false);
                }
            }
            auto content_ = IOUtil::read_file(case_name);
            app_perf_results[case_name] = json::parse(content_);
        }
    }

    virtual void TearDown(){
       
    }

    std::map<std::string, json> app_perf_results;
};

TEST_F(AppPerfTests, ReadFile) {
    auto query_str = IOUtil::read_file(app_perf_pos_cases[0].name);
    LOG(INFO) << query_str << "\n";
    ASSERT_TRUE(query_str!="");
}

TEST_F(AppPerfTests, GetMapKeys) { 
    auto keys = get_map_keys(DimProductMapping);
    LOG(INFO) << keys.size() << "\n";
    ASSERT_EQ(15, keys.size());
}

TEST_F(AppPerfTests, GetMapValues) { 
    auto values = get_map_values(DimProductMapping);
    LOG(INFO) << values.size() << "\n";
    ASSERT_EQ(15, values.size());
}


TEST_F(AppPerfTests, GetApiProductFields) { 
    auto app_perf_result = app_perf_results.begin()->second;
    std::cerr << app_perf_result["start_date"] << std::endl;
    Compare c {app_perf_result};
    auto values = c.get_api_products_fields(DimProductMapping);
    ASSERT_TRUE(values.size() > 0);
}

TEST_F(AppPerfTests, JsonDumpStdVector) {
    std::string country_code = "US,CN,JP,CA";
    std::vector<std::string> results_{}; 
    pystring::split(country_code, results_, ",");
    json js = results_;
    ASSERT_EQ(4, js.size());
}

TEST_F(AppPerfTests, JsonDelInnerKey) {
    auto js_str = R"(
        {
            "person": {
                "name": "Zhangsan",
                "age": 34
            },
            "grade": 3
        }
    )";
    json js = json::parse(js_str);
    js["person"].erase("age");
    LOG(INFO) << js.dump() << "\n";
}

TEST_F(AppPerfTests, ReadQueryFileAndReplaceConsts) {
    json prod = json::parse(R"({
        "product_id": 1111,
        "market_code": "google-play",
        "start_date": "2021-01-01",
        "end_date": "2021-01-31",
        "countries": "CN,US,JP",
        "devices": "android-all,android-tv",
        "granularity": "monthly"
        })");
    auto apps_meta_query_str = read_query_file_and_replace_consts(prod, apps_meta_file);
    LOG(INFO) << apps_meta_query_str << "\n";
}

TEST_F(AppPerfTests, ReadQueryFileAndReplaceConstsAllCountries) {
    json prod = json::parse(R"({
        "product_id": 1111,
        "market_code": "google-play",
        "start_date": "2021-01-01",
        "end_date": "2021-01-31",
        "countries": "all_supported",
        "devices": "android-all,android-tv",
        "granularity": "monthly"
        })");
    auto apps_meta_query_str = read_query_file_and_replace_consts(prod, apps_meta_file);
    LOG(INFO) << apps_meta_query_str << "\n";
}


TEST_F(AppPerfTests, ParseDimProductFields) {
    auto dim_file_str = IOUtil::read_file(test_dim_parse_data_file);
    auto dim_file = json::parse(dim_file_str);
    auto dim_keys_ = get_map_values(DimProductMapping);
    auto dim_values = parse_dim_product_fields(dim_file, dim_keys_);
    auto api_values = convert_dim_values_to_api_values(dim_values, DimProductMapping);
    LOG(INFO) << api_values << "\n";
}

TEST_F(AppPerfTests, TestProductMetadata) {
    bool is_case_pass = true;
    for(auto&& case_item: app_perf_results) {
        auto app_perf_file = case_item.first;
        auto app_perf_result = case_item.second;
        auto comp_ = Compare(app_perf_result);
        auto is_value_equal = comp_.compare_api_and_www_meta_equal(DimProductMapping, apps_meta_file); 
        if(!is_value_equal) {
            LOG(ERROR) << "[" << app_perf_file  << "] test [test_product_metadata] failed!\n"; 
            is_case_pass = false;
        }
    }
    ASSERT_TRUE(is_case_pass);
}

test/datas/app_perf/apps_meta_data.json

{
    "facets": ["product_id"],
    "filters": {
        "product_id": {
            "equal": ${product_id}
        },
        "granularity": {
            "equal": "${granularity}"
        },
        "date": {
            "between": [
              "${start_date}",
              "${end_date}"
            ]
        },
        "country_code": {
            "in": ${country_code}
        }
    },
    "fields": {
        "product_id": {
            "fields": [
                "name",
                "market_code",
                "device_code",
                "description",
                "price",
                "has_iap",
                "unified_product_id",
                "category_id",
                "publisher_id"
            ],
            "publisher_id": {
                "fields": [
                    "name",
                    "market_code",
                    "website",
                    "company_id"
                ],
                "company_id": {
                    "fields": [
                        "name",
                        "exchange",
                        "ticker_symbol",
                        "website",
                        "is_public_company",
                        "country_code"
                    ]
                }
            },
            "category_id": {"fields": ["name", "slug"]}
        }
    }
}

impl/test_cfg.cpp

#include "api_accuracy/test_cfg.h"

std::string api_host = "tai4-api.appannie.com";
std::string www_host = "api2.appannie.com";

std::string v2_query_path = "/v2/query";
int max_compare_count = 10; 

std::map<std::string, std::string> www_headers{
    {"Authorization", "Bearer 501b0ae76f7732aa7335564e7795ad9bb8ffe493"},
    {"Content-Type", "application/json"}
};

std::map<std::string, std::string> api_headers{
    {"Authorization", "Bearer cb5685cc45423934256c893cff23408b1a50208c"},
    {"Content-Type", "application/json"}
};

bool use_file = true;

std::string apps_meta_file = "../datas/app_perf/apps_meta_data.json";
std::string test_dim_parse_data_file = "../datas/app_perf/test_dim_parse_data.json";

cases/app_perf_cases.h

#ifndef _FREDRIC_APP_PERF_CASES_H_
#define _FREDRIC_APP_PERF_CASES_H_
#include "api_accuracy/utils/case.h"

#include <vector>

extern std::vector<Case> app_perf_pos_cases;

#endif

cases/app_perf_cases.cpp

#include "api_accuracy/cases/app_perf_cases.h"

std::vector<Case> app_perf_pos_cases {
    {"../datas/app_perf/test545__200_ok_monthly_api_response", "/v1.3/portfolio/app-performance/less?company_id=1000200000000034&granularity=monthly&start_date=2020-01-01&end_date=2020-03-31&countries=US,CN,JP,GB", 0}
};

程序输出如下，

image.png