Added cpp tests to linter integration tests

.github/scripts/conan-profile.sh

@@ -12,6 +12,5 @@ profile="$(conan profile path default)"
 
 mv "$profile" "${profile}.bak"
 sed -e 's/^\(compiler\.cppstd=\).\{1,\}$/\1'"$std/" \
-    -e 's/^\(compiler\.version=\).\{1,\}$/\1'"$version/" \
     "${profile}.bak" > "$profile"
 rm "${profile}.bak"

exchange/CMakeLists.txt

@@ -242,7 +242,7 @@ target_include_directories(
     "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"
 )
 
-target_compile_features(LINTER_lib PUBLIC cxx_std_20)
+target_compile_features(LINTER_lib PUBLIC cxx_std_23)
 
 target_link_libraries(LINTER_lib PUBLIC fmt::fmt)
 target_link_libraries(LINTER_lib PUBLIC quill::quill)
@@ -275,7 +275,7 @@ add_executable(LINTER::exe ALIAS LINTER_exe)
 
 set_property(TARGET LINTER_exe PROPERTY OUTPUT_NAME LINTER)
 
-target_compile_features(LINTER_exe PRIVATE cxx_std_20)
+target_compile_features(LINTER_exe PRIVATE cxx_std_23)
 
 target_link_libraries(LINTER_exe PRIVATE LINTER_lib)
 target_link_libraries(LINTER_exe PRIVATE fmt::fmt)
@@ -295,7 +295,7 @@ add_executable(LINTER_spawner::exe ALIAS LINTER_spawner_exe)
 
 set_property(TARGET LINTER_spawner_exe PROPERTY OUTPUT_NAME LINTER_spawner)
 
-target_compile_features(LINTER_spawner_exe PRIVATE cxx_std_20)
+target_compile_features(LINTER_spawner_exe PRIVATE cxx_std_23)
 
 target_link_libraries(LINTER_spawner_exe PRIVATE LINTER_spawner_lib)
 target_link_libraries(LINTER_spawner_exe PRIVATE CURL::libcurl)
@@ -307,8 +307,8 @@ target_link_libraries(LINTER_spawner_exe PRIVATE Python3::Python)
 # ---- COMMON ----------
 
 add_library(COMMON_lib OBJECT     
-    src/common/file_operations/file_operations.cpp
     src/common/firebase/firebase.cpp
+    src/common/file_operations/file_operations.cpp
     src/common/util.cpp
     src/common/types/decimal.cpp
     src/common/types/algorithm/local_algorithm.cpp
@@ -336,11 +336,11 @@ target_link_libraries(COMMON_lib PRIVATE boost::boost)
 target_link_libraries(EXCHANGE_lib PUBLIC COMMON_lib)
 target_link_libraries(EXCHANGE_exe PRIVATE COMMON_lib)
 
-target_link_libraries(LINTER_lib PRIVATE COMMON_lib)
-target_link_libraries(LINTER_exe PUBLIC COMMON_lib)
+target_link_libraries(LINTER_lib PUBLIC COMMON_lib)
+target_link_libraries(LINTER_exe PRIVATE COMMON_lib)
 
-target_link_libraries(LINTER_spawner_lib PRIVATE COMMON_lib)
-target_link_libraries(LINTER_spawner_exe PUBLIC COMMON_lib)
+target_link_libraries(LINTER_spawner_lib PUBLIC COMMON_lib)
+target_link_libraries(LINTER_spawner_exe PRIVATE COMMON_lib)
 
 target_link_libraries(WRAPPER_lib PUBLIC COMMON_lib)
 target_link_libraries(WRAPPER_exe PRIVATE COMMON_lib)

exchange/src/common/compilation/compile_cpp.cpp

@@ -2,6 +2,8 @@
 
 #include "common/file_operations/file_operations.hpp"
 
+#include <optional>
+
 namespace nutc::common {
 namespace {
 std::string
@@ -19,6 +21,25 @@ get_cpp_template_path()
 
     return template_path_env;
 }
+
+std::optional<std::string>
+exec_command(const std::string& command)
+{
+    std::array<char, 128> buffer{};
+    std::string result;
+
+    FILE* pipe = popen((command + " 2>&1").c_str(), "r");
+    if (pipe == nullptr) {
+        throw std::runtime_error("popen() failed!");
+    }
+    while (fgets(buffer.data(), buffer.size(), pipe) != nullptr) {
+        result += buffer.data();
+    }
+    if (pclose(pipe) != 0) {
+        return result;
+    }
+    return std::nullopt;
+}
 } // namespace
 
 std::string
@@ -33,12 +54,13 @@ compile_cpp(const std::filesystem::path& filepath)
         filepath.string(), get_cpp_template_path()
     );
 
-    int result = system(command.c_str());
+    std::optional<std::string> result = exec_command(command);
 
-    if (result != 0) {
-        throw std::runtime_error(
-            fmt::format("Compilation of {} failed", filepath.string())
-        );
+    if (result) {
+        throw std::runtime_error(fmt::format(
+            "Compilation of {} failed. Compiler output below:\n {}", filepath.string(),
+            result.value()
+        ));
     }
     return binary_output;
 }

exchange/src/linter/runtime/cpp/cpp_runtime.cpp

@@ -1,7 +1,6 @@
 #include "cpp_runtime.hpp"
 
 #include "common/compilation/compile_cpp.hpp"
-#include "common/file_operations/file_operations.hpp"
 
 #include <dlfcn.h>
 #include <fcntl.h>
@@ -13,42 +12,8 @@
 #include <cerrno>
 #include <cstdlib>
 
-#include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <stdexcept>
-
-namespace {
-namespace fs = std::filesystem;
-
-std::pair<int, std::filesystem::path>
-get_temp_file()
-{
-#ifdef __APPLE__
-    std::string template_path = (fs::temp_directory_path() / "algoXXXXXX").string();
-    std::vector<char> writable_template_path(
-        template_path.begin(), template_path.end()
-    );
-    writable_template_path.push_back('\0');
-    int fd = mkstemp(writable_template_path.data());
-    if (fd == -1) {
-        throw std::runtime_error("Failed to get file descriptor for temporary file");
-    }
-
-    return {fd, writable_template_path.data()};
-
-#else
-    int memfd = memfd_create("algo", MFD_CLOEXEC);
-    if (memfd == -1) {
-        throw std::runtime_error("Failed to create memfd");
-    }
-
-    return {memfd, "/proc/self/fd/" + std::to_string(memfd)};
-
-#endif
-}
-
-} //   namespace
 
 namespace nutc::lint {
 
@@ -64,9 +29,9 @@ CppRuntime::CppRuntime(
 
 CppRuntime::~CppRuntime()
 {
-    // TODO: shoudl not do
-    dlclose(dl_handle_);
-    close(fd_);
+    if (dl_handle_ != nullptr) {
+        dlclose(dl_handle_);
+    }
 }
 
 std::optional<std::string>
@@ -80,12 +45,17 @@ CppRuntime::init()
     algo_file << algo_ << std::flush;
     algo_file.close();
 
-    std::string compiled_binary_path = common::compile_cpp(temp_file.string());
+    // TODO: improve
+    std::string compiled_binary_path;
+    try {
+        compiled_binary_path = common::compile_cpp(temp_file.string());
+    } catch (const std::exception& e) {
+        return fmt::format("[linter] failed to compile C++ code: {}", e.what());
+    }
 
     dl_handle_ = dlopen(compiled_binary_path.c_str(), RTLD_NOW);
     if (dl_handle_ == nullptr) {
         std::string err = dlerror();
-        close(fd_);
         return fmt::format("[linter] failed to dlopen: {}", err);
     }
 
@@ -100,8 +70,6 @@ CppRuntime::init()
 
     if (init_func == nullptr || on_trade_update_func_ == nullptr
         || on_orderbook_update_func_ == nullptr || on_account_update_func_ == nullptr) {
-        dlclose(dl_handle_);
-        close(fd_);
         return fmt::format("[linter] failed to dynamically load functions");
     }
     strategy_object_ =

exchange/src/linter/runtime/cpp/cpp_runtime.hpp

@@ -50,7 +50,6 @@ class CppRuntime : public Runtime {
     OnAccountUpdateFunc on_account_update_func_;
 
     Strategy* strategy_object_;
-    void* dl_handle_;
-    int fd_;
+    void* dl_handle_{};
 };
 } // namespace nutc::lint

exchange/src/linter/spawner/main.cpp

@@ -37,11 +37,17 @@ mock_cancel_func(nutc::common::Ticker, std::int64_t)
 }
 } // namespace
 
+void
+send_response(const std::string& response)
+{
+    std::cout << nutc::common::base64_encode(response) << std::endl;
+}
+
 int
 main(int argc, char* argv[])
 {
     if (argc < 2) {
-        std::cout << "[linter] no language provided\n";
+        send_response("[linter] no language provided");
         return 1;
     }
 
@@ -65,18 +71,18 @@ main(int argc, char* argv[])
         lint_result = nutc::lint::lint(runtime);
     }
     else {
-        std::cout << "[linter] no language provided\n";
+        send_response("[linter] no language provided");
         return 1;
     }
 
     auto output = glz::write_json(lint_result);
     if (output) {
-        std::cout << *output << std::endl;
+        send_response(output.value());
     }
     else {
-        std::cout << fmt::format(
+        send_response(fmt::format(
             "[linter] ERROR WRITING LINT RESULT: {}", glz::format_error(output.error())
-        ) << std::endl;
+        ));
     }
 
     return 0;

exchange/src/linter/spawning/spawning.cpp

@@ -96,8 +96,9 @@ LintProcessManager::spawn_client(const std::string& algo_code, AlgoLanguage lang
                 if (child->running()) {
                     child->terminate();
                 }
+				std::string decoded_message = common::base64_decode(message);
 
-                auto error = glz::read_json<nutc::lint::lint_result>(res, message);
+                auto error = glz::read_json<nutc::lint::lint_result>(res, decoded_message);
                 if (error) {
                     res = {
                         false, "Internal server error. Reach out to "

exchange/template.cpp

@@ -5,6 +5,8 @@
 // #include "template.hpp"
 
 #include <functional>
+#include <string>
+#include <cstdint>
 
 using PlaceMarketOrder = std::function<bool(Side, Ticker, float)>;
 using PlaceLimitOrder = std::function<std::int64_t(Side, Ticker, float, float, bool)>;

exchange/test/CMakeLists.txt

@@ -31,7 +31,8 @@ add_executable(NUTC_tests
   src/unit/types/decimal.cpp
 
   src/integration/tests/basic.cpp
-  src/integration/tests/linter_test.cpp
+  src/integration/tests/linter_py_test.cpp
+  src/integration/tests/linter_cpp_test.cpp
   src/integration/tests/cancellation.cpp
   )
 

exchange/test/src/integration/tests/linter_cpp_test.cpp

@@ -0,0 +1,106 @@
+#include "linter/spawning/spawning.hpp"
+
+#include <gtest/gtest.h>
+
+#include <iostream>
+
+class IntegrationLinterCppTest : public ::testing::Test {
+protected:
+    nutc::spawning::LintProcessManager manager;
+};
+
+const std::string basic_algo = R"(#include <cstdint>
+#include <string>
+enum class Side { buy = 0, sell = 1 };
+enum class Ticker : std::uint8_t { ETH = 0, BTC = 1, LTC = 2 }; // NOLINT
+bool place_market_order(Side side, Ticker ticker, float quantity);
+std::int64_t place_limit_order(Side side, Ticker ticker, float quantity,
+                               float price, bool ioc = false);
+bool cancel_order(Ticker ticker, std::int64_t order_id);
+
+class Strategy {
+public:
+  Strategy() {
+	place_market_order(Side::buy, Ticker::ETH, 1.0);
+  }
+
+  void on_trade_update(Ticker ticker, Side side, float quantity, float price) {place_limit_order(Side::buy, Ticker::LTC, 1.0, 1.0);}
+  void on_orderbook_update(Ticker ticker, Side side, float quantity,
+                           float price) {place_market_order(Side::sell, Ticker::BTC, 1.0);}
+
+  void on_account_update(Ticker ticker, Side side, float price, float quantity,
+                         float capital_remaining) {cancel_order(Ticker::BTC, 5);}
+};
+)";
+
+const std::string syntax_error = R"(#include <cstdint>
+#include <string>
+enum class Side { buy = 0, sell = 1 };
+enum class Ticker : std::uint8_t { ETH = 0, BTC = 1, LTC = 2 }; // NOLINT
+bool place_market_order(Side side, Ticker ticker, float quantity);
+std::int64_t place_limit_order(Side side, Ticker ticker, float quantity,
+                               float price, bool ioc = false);
+bool cancel_order(Ticker ticker, std::int64_t order_id);
+
+class Strategy {
+public:
+  Strategy() {
+  }
+
+  void on_trade_update(Ticker ticker, Side side, float quantity, float price) {}
+  void on_orderbook_update(Ticker ticker, Side side, float quantity,
+                           float price) { SYNTAX ERROR }
+
+  void on_account_update(Ticker ticker, Side side, float price, float quantity,
+                         float capital_remaining) {}
+};
+)";
+
+const std::string exception_thrown = R"(#include <cstdint>
+#include <string>
+#include <stdexcept>
+enum class Side { buy = 0, sell = 1 };
+enum class Ticker : std::uint8_t { ETH = 0, BTC = 1, LTC = 2 }; // NOLINT
+bool place_market_order(Side side, Ticker ticker, float quantity);
+std::int64_t place_limit_order(Side side, Ticker ticker, float quantity,
+                               float price, bool ioc = false);
+bool cancel_order(Ticker ticker, std::int64_t order_id);
+
+class Strategy {
+public:
+  Strategy() {
+  }
+
+  void on_trade_update(Ticker ticker, Side side, float quantity, float price) {}
+  void on_orderbook_update(Ticker ticker, Side side, float quantity,
+                           float price) { throw std::runtime_error("This is an error"); }
+
+  void on_account_update(Ticker ticker, Side side, float price, float quantity,
+                         float capital_remaining) {}
+};
+)";
+
+using nutc::spawning::AlgoLanguage;
+
+TEST_F(IntegrationLinterCppTest, basic)
+{
+    auto lint_result = manager.spawn_client(basic_algo, AlgoLanguage::Cpp);
+    std::cout << "first " << lint_result.message << "\n";
+    ASSERT_TRUE(lint_result.success);
+}
+
+TEST_F(IntegrationLinterCppTest, SyntaxErrorDetection)
+{
+    auto lint_result = manager.spawn_client(syntax_error, AlgoLanguage::Cpp);
+    ASSERT_FALSE(lint_result.success);
+    EXPECT_TRUE(lint_result.message.contains("‘SYNTAX’ was not declared in this scope")
+    );
+}
+
+TEST_F(IntegrationLinterCppTest, RuntimeError)
+{
+    auto lint_result = manager.spawn_client(exception_thrown, AlgoLanguage::Cpp);
+    ASSERT_FALSE(lint_result.success);
+    EXPECT_TRUE(lint_result.message.contains("Failed to run on_orderbook_update"));
+    EXPECT_TRUE(lint_result.message.contains("This is an error"));
+}