feat: google tests, interfaces, coverage, github action, housekeeping, threading work

Author: milsanore

.github/workflows/build.yml

@@ -31,6 +31,10 @@ jobs:
 
       - name: Build
         run: |
-          conan install . --build=missing -s build_type=Release
-          cmake --preset=conan-release
-          cmake --build --preset=conan-release
+          conan install . --build=missing -s build_type=Debug
+          cmake --preset=conan-debug
+          cmake --build --preset=conan-debug
+
+      - name: Test
+        run: |
+          ctest --test-dir build/Debug --output-on-failure

.vscode/launch.json

@@ -5,7 +5,7 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"name": "(gdb) Launch",
+			"name": "(gdb) Trader",
 			"type": "cppdbg",
 			"request": "launch",
 			"program": "${workspaceFolder}/build/Debug/tradercpp",
@@ -30,6 +30,33 @@
 			],
 			"preLaunchTask": "build",
       		"miDebuggerPath": "/usr/bin/gdb"
+		},
+		{
+			"name": "(gdb) Unit Tests",
+			"type": "cppdbg",
+			"request": "launch",
+			"program": "${workspaceFolder}/build/Debug/tests/unit_tests",
+			"args": [],
+			"stopAtEntry": false,
+			"cwd": "${workspaceFolder}",
+			"environment": [],
+			"envFile": "${workspaceFolder}/.env",
+			"externalConsole": false,
+			"MIMode": "gdb",
+			"setupCommands": [
+				{
+					"description": "Enable pretty-printing for gdb",
+					"text": "-enable-pretty-printing",
+					"ignoreFailures": true
+				},
+				{
+					"description": "Set Disassembly Flavor to Intel",
+					"text": "-gdb-set disassembly-flavor intel",
+					"ignoreFailures": true
+				}
+			],
+			"preLaunchTask": "build",
+      		"miDebuggerPath": "/usr/bin/gdb"
 		}
 	]
 }

CMakeLists.txt

@@ -4,15 +4,9 @@ project(tradercpp)
 set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED YES)
 
-# Define the source files
-file(GLOB_RECURSE SOURCES "src/*.cpp")
-
-# Create the executable
-add_executable(tradercpp ${SOURCES})
-
 ############################################
-
 # Conan-generated toolchain setup
+
 include(${CMAKE_BINARY_DIR}/conan_toolchain.cmake OPTIONAL RESULT_VARIABLE _found_toolchain)
 if(_found_toolchain)
     message(STATUS "Conan toolchain included")
@@ -21,18 +15,46 @@ endif()
 # Find packages from Conan
 find_package(concurrentqueue REQUIRED)
 find_package(ftxui REQUIRED)
+find_package(GTest REQUIRED)
 find_package(OpenSSL REQUIRED)
 find_package(quickfix REQUIRED CONFIG)
 find_package(libsodium REQUIRED)
 find_package(spdlog REQUIRED)
 
-# Link them to the executable
-target_link_libraries(tradercpp PRIVATE
-    concurrentqueue::concurrentqueue
-    ftxui::ftxui
-    OpenSSL::SSL
-    OpenSSL::Crypto
-    quickfix::quickfix
-    libsodium::libsodium
-    spdlog::spdlog
+############################################
+# Collect source files
+
+file(GLOB_RECURSE ALL_SOURCES "src/*.cpp")
+# Separate main.cpp from the rest of the sources
+list(FILTER ALL_SOURCES EXCLUDE REGEX ".*main\\.cpp$")
+set(SOURCES ${ALL_SOURCES})
+
+############################################
+# Create core logic library
+add_library(traderlib STATIC ${SOURCES})
+
+# TODO: MAKE CONDITIONAL
+# Add coverage flags to the traderlib target
+target_compile_options(traderlib PRIVATE -O0 -g --coverage)
+target_link_libraries(traderlib PRIVATE --coverage)
+
+# Link dependencies to the library (so both exe and tests get them)
+target_link_libraries(traderlib PUBLIC
+        concurrentqueue::concurrentqueue
+        ftxui::ftxui
+        OpenSSL::SSL
+        OpenSSL::Crypto
+        quickfix::quickfix
+        libsodium::libsodium
+        spdlog::spdlog
 )
+
+############################################
+# Create main executable
+add_executable(tradercpp "src/main.cpp")
+target_link_libraries(tradercpp PRIVATE traderlib)
+
+############################################
+# Enable `ctest`
+enable_testing()
+add_subdirectory(tests)

Makefile

@@ -13,7 +13,7 @@ help: Makefile
 	@echo " Choose a command to run:"
 	@sed -n 's/^##//p' $< | column -t -s ':' | sed -e 's/^/ /'
 
-## withenv: 😭 `make` executes every line as a new shell. this is a workaround. `make withenv RECIPE=init`
+## withenv: 😭 `make` executes every line as a new shell. this is a workaround => `make withenv RECIPE=init`
 .PHONY: withenv
 withenv:
 	test -e .env || cp .env.example .env
@@ -34,6 +34,13 @@ init:
 build-debug:
 	cmake --build --preset=conan-debug
 
+## test: 🧪 run google-test
+.PHONY: test
+test:
+	cmake --build --preset=conan-debug
+	ctest --test-dir build/Debug --output-on-failure
+	lcov --gcov-tool gcov --capture --directory . --output-file lcov.info
+
 ## build-release: 🔨🔨 compile (prod)
 .PHONY: build-release
 build-release:

README.md

@@ -7,15 +7,22 @@ a proof-of-concept, showcasing some c++ coding combined with some fintech concep
 
 ## REQUIREMENTS
 - C++20
-- Conan
-- CMake
-- a local proxy (e.g. stunnel) for TLS encryption
+- `Conan` (and a conan profile)
+- `CMake`
+- a local proxy for TLS encryption (e.g. `stunnel`)
+- a Binance account, with an Ed25519 token that has FIX read permissions enabled 
+- `lcov`
 
 ## BUILD AND RUN
 (NB: this app uses `make` as a task runner, but it's not essential)
-1. `make init`
-2. `make build-debug`
-3. `make withenv RECIPE=run-debug`
+1. copy `.env.example` to `.env`, and set your public/private keys
+2. run an SSL tunnel (`stunnel binance/stunnel_prod.conf`)
+3. `make init`
+4. `make build-debug`
+5. `make withenv RECIPE=run-debug`
+
+## TEST
+`make test`
 
 ## HELP
 `make`
@@ -28,29 +35,32 @@ a proof-of-concept, showcasing some c++ coding combined with some fintech concep
 - ✅ subscribe to price updates
 - create a basic trading signal (e.g. standard deviations)
 - fire an order
-- test in the Binance test enviroment
+- test in the Binance test environment
 
 
 ## NON-FUNCTIONAL
 - ✅ basic cpp app to start with
 - ✅ makefile and build chain
 - ✅ package management
 - ✅ debugging
-- UI can come later (perhaps explore curses)
-- logging
-    - fast
+- ✅ UI
+  - ✅ publish messages to thread-safe queue
+  - ✅ consume messages from thread-safe queue on a worker thread
+  - interrupt/ctrl+c signal
+  - 60fps limit
+- ✅ logging
+    - ✅ fast
     - structured
     - basic schema (severity, correlationId)
-- dependency injection
-- single-threaded to start with, then re-architect (and mermaid diagram)
-- demo video (https://asciinema.org)
+- ✅ dependency injection
+- ✅ single-threaded to start with, then re-architect (and mermaid diagram)
 - nix virtual environment
 - decimal type
 - sparse arrays
 - release binaries on github
 - ccache.dev
 - zeromq + protobufs?
-- interrupt/ctrl+c signal
+- valgrind/cachegrind
 
 # STANDARDS
 - high unit-test coverage + badge
@@ -69,6 +79,7 @@ a proof-of-concept, showcasing some c++ coding combined with some fintech concep
     - grafana+tempo via docker-compose
 - conventional commits
 - automated semantic versioning
+- memory-mapped files
 
 # CREDITS
-- https://github.com/binance/binance-fix-connector-python
+- https://github.com/binance/binance-fix-connector-python

conanfile.txt

@@ -5,6 +5,7 @@ openssl/3.5.2
 ftxui/6.0.2
 concurrentqueue/1.0.4
 spdlog/1.15.3
+gtest/1.17.0
 
 [generators]
 CMakeToolchain

src/binance/Auth.cpp

@@ -17,9 +17,23 @@
 
 namespace Binance {
 
-// static member function
-std::vector<unsigned char> Auth::getSeedFromPem(const std::string& pemPath) {
-	FILE* fp = fopen(pemPath.c_str(), "r");
+Auth::Auth(std::string& apiKey, std::string& privatePemPath) : apiKey_(apiKey), privatePemPath_(privatePemPath) {
+	if (sodium_init() < 0)
+		throw std::runtime_error("libsodium failed to initialize");
+}
+
+const std::string& Auth::getApiKey() const {
+	return apiKey_;
+}
+
+std::string Auth::signPayload(const std::string& payload) {
+	const std::vector<unsigned char> seed = getSeedFromPem();
+	const std::string signature = signPayload(payload, seed);
+	return signature;
+}
+
+std::vector<unsigned char> Auth::getSeedFromPem() const {
+	FILE* fp = fopen(privatePemPath_.c_str(), "r");
 	if (!fp) throw std::runtime_error("Failed to open PEM file");
 	EVP_PKEY* pkey = PEM_read_PrivateKey(fp, nullptr, nullptr, nullptr);
 	fclose(fp);
@@ -36,7 +50,7 @@ std::vector<unsigned char> Auth::getSeedFromPem(const std::string& pemPath) {
 	return seed;
 }
 
-// static member function
+// static
 std::string Auth::signPayload(const std::string& payload, const std::vector<unsigned char>& seed) {
 	unsigned char pk[crypto_sign_PUBLICKEYBYTES];
 	unsigned char sk[crypto_sign_SECRETKEYBYTES]; // 64 bytes
@@ -61,4 +75,13 @@ std::string Auth::signPayload(const std::string& payload, const std::vector<unsi
 	return b64;
 }
 
+void Auth::clearKeys()
+{
+	// logon successful, nullify access keys
+	std::ranges::fill(apiKey_, 0);
+	apiKey_.clear();
+	std::ranges::fill(privatePemPath_, 0);
+	privatePemPath_.clear();
+}
+
 }

src/binance/Auth.h

@@ -1,27 +1,32 @@
 #ifndef BINANCEAUTH_H
 #define BINANCEAUTH_H
 
-#include <vector>
 #include <string>
+#include <vector>
+#include "IAuth.h"
 
 namespace Binance {
 
 /// @brief Binance's proprietary FIX authentication mechanism - helper functions
-class Auth final {
+class Auth final : public IAuth {
 public:
-    /// Fetch a 32-byte Ed25519 seed from a private key PEM file (using OpenSSL)
-    ///
-    /// @param pemPath path to a private-key PEM file
-    /// @return 32-byte Ed25519 seed
-    static std::vector<unsigned char> getSeedFromPem(const std::string& pemPath);
-
+    Auth(std::string& apiKey, std::string& privatePemPath);
+    std::string signPayload(const std::string& payload) override;
     /// Generate a payload signature using a private key.
     /// Expand the key to a 64-byte secret key (using libsodium), sign a payload, output base64 signature.
-    ///
     /// @param payload payload to be signed
     /// @param seed a 32-byte Ed25519 seed
     /// @return base64 payload signature
     static std::string signPayload(const std::string& payload, const std::vector<unsigned char>& seed);
+    const std::string& getApiKey() const override;
+    void clearKeys() override;
+
+private:
+    std::string& apiKey_;
+    std::string& privatePemPath_;
+    /// Fetch a 32-byte Ed25519 seed from a private key PEM file (using OpenSSL)
+    /// @return 32-byte Ed25519 seed
+    std::vector<unsigned char> getSeedFromPem() const;
 };
 
 }

src/binance/Config.cpp

@@ -4,8 +4,8 @@
 #include <stdexcept>
 #include <string>
 #include <vector>
-#include "Config.h"
 #include "spdlog/spdlog.h"
+#include "Config.h"
 
 namespace Binance {
 
@@ -20,6 +20,8 @@ std::string getEnvOrThrow(const char* key) {
     throw std::runtime_error(std::format("envvar not defined, key [{}]", key));
 };
 
+// TODO: for keys, use `std::vector<unsigned char>` instead of string
+
 /// @brief load Binance configuration from env
 /// (static member function)
 /// @return Config object 

src/binance/Config.h

@@ -9,7 +9,9 @@ namespace Binance {
 /// @brief Binance config parameters, fetched from env
 struct Config{
 public:
-    const std::string apiKey, privateKeyPath, fixConfigPath;
+    // TODO: MAKE UNIQUE POINTERS
+    std::string apiKey, privateKeyPath;
+    const std::string fixConfigPath;
     const std::vector<std::string> symbols;
     //
     static Config fromEnv();