ADD: Improve testing around TimeseriesGetRange

Author: threecgreen

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.38.0 - TBD
+
+### Enhancements
+- Added log level prefix to `ConsoleLogReceiver` output
+
+### Breaking changes
+- Added new optional `ShouldLog` virtual method to `ILogReceiver` to
+  filter the levels of log messages that will be sent to the receiver
+
 ## 0.37.1 - 2025-06-03
 
 ### Bug fixes

include/databento/detail/buffer.hpp

@@ -80,7 +80,7 @@ class Buffer : public IReadable, public IWritable {
 
   UniqueBufPtr buf_;
   std::byte* end_;
-  std::byte* read_pos_{};
-  std::byte* write_pos_{};
+  std::byte* read_pos_;
+  std::byte* write_pos_;
 };
 }  // namespace databento::detail

include/databento/log.hpp

@@ -19,11 +19,13 @@ class ILogReceiver {
   virtual ~ILogReceiver() = default;
 
   virtual void Receive(databento::LogLevel level, const std::string& msg) = 0;
+  virtual bool ShouldLog(databento::LogLevel) const { return true; }
 };
 
 class NullLogReceiver : public ILogReceiver {
  public:
   void Receive(databento::LogLevel, const std::string&) override {}
+  bool ShouldLog(databento::LogLevel) const override { return false; }
 };
 
 class ConsoleLogReceiver : public ILogReceiver {
@@ -34,9 +36,15 @@ class ConsoleLogReceiver : public ILogReceiver {
   ConsoleLogReceiver(LogLevel min_level, std::ostream& stream);
 
   void Receive(LogLevel level, const std::string& msg) override;
+  bool ShouldLog(databento::LogLevel level) const override {
+    return level > min_level_;
+  }
 
  private:
   std::ostream& stream_;
   const databento::LogLevel min_level_;
 };
+
+std::ostream& operator<<(std::ostream& out, LogLevel level);
+const char* ToString(LogLevel level);
 }  // namespace databento

src/detail/buffer.cpp

@@ -67,7 +67,7 @@ void Buffer::Reserve(std::size_t capacity) {
 void Buffer::Shift() {
   const auto unread_bytes = ReadCapacity();
   if (unread_bytes) {
-    std::copy(read_pos_, write_pos_, buf_.get());
+    std::copy(ReadBegin(), ReadEnd(), buf_.get());
   }
   read_pos_ = buf_.get();
   write_pos_ = read_pos_ + unread_bytes;

src/live_blocking.cpp

@@ -194,7 +194,11 @@ const databento::Record* LiveBlocking::NextRecord(
 void LiveBlocking::Stop() { client_.Close(); }
 
 void LiveBlocking::Reconnect() {
-  log_receiver_->Receive(LogLevel::Info, "Reconnecting");
+  if (log_receiver_->ShouldLog(LogLevel::Info)) {
+    std::ostringstream log_msg;
+    log_msg << "Reconnecting to " << gateway_ << ':' << port_;
+    log_receiver_->Receive(LogLevel::Info, log_msg.str());
+  }
   client_ = detail::TcpClient{gateway_, port_};
   sub_counter_ = 0;
   session_id_ = this->Authenticate();
@@ -227,7 +231,7 @@ std::string LiveBlocking::DecodeChallenge() {
   // first line is version
   std::string response{reinterpret_cast<const char*>(buffer_.ReadBegin()),
                        buffer_.ReadCapacity()};
-  {
+  if (log_receiver_->ShouldLog(LogLevel::Debug)) {
     std::ostringstream log_ss;
     log_ss << "[LiveBlocking::DecodeChallenge] Challenge: " << response;
     log_receiver_->Receive(LogLevel::Debug, log_ss.str());
@@ -283,12 +287,13 @@ std::uint64_t LiveBlocking::Authenticate() {
   client_.WriteAll(req);
   const std::uint64_t session_id = DecodeAuthResp();
 
-  std::ostringstream log_ss;
-  log_ss << "[LiveBlocking::Authenticate] Successfully authenticated with "
-            "session_id "
-         << session_id;
-  log_receiver_->Receive(LogLevel::Info, log_ss.str());
-
+  if (log_receiver_->ShouldLog(LogLevel::Info)) {
+    std::ostringstream log_ss;
+    log_ss << "[LiveBlocking::Authenticate] Successfully authenticated with "
+              "session_id "
+           << session_id;
+    log_receiver_->Receive(LogLevel::Info, log_ss.str());
+  }
   return session_id;
 }
 

src/log.cpp

@@ -21,7 +21,33 @@ ConsoleLogReceiver::ConsoleLogReceiver(LogLevel min_level, std::ostream& stream)
     : stream_{stream}, min_level_{min_level} {}
 
 void ConsoleLogReceiver::Receive(LogLevel level, const std::string& msg) {
-  if (level >= min_level_) {
-    stream_ << msg << '\n';
+  if (ShouldLog(level)) {
+    stream_ << level << ": " << msg << '\n';
   }
 }
+
+namespace databento {
+std::ostream& operator<<(std::ostream& out, LogLevel level) {
+  out << ToString(level);
+  return out;
+}
+const char* ToString(LogLevel level) {
+  switch (level) {
+    case LogLevel::Debug: {
+      return "DEBUG";
+    }
+    case LogLevel::Info: {
+      return "INFO";
+    }
+    case LogLevel::Warning: {
+      return "WARN";
+    }
+    case LogLevel::Error: {
+      return "ERROR";
+    }
+    default: {
+      return "UNKNOWN";
+    };
+  }
+}
+}  // namespace databento

tests/CMakeLists.txt

@@ -18,7 +18,7 @@ verbose_message("Adding tests under ${CMAKE_PROJECT_NAME}Tests...")
 set(
   test_headers
   include/mock/mock_http_server.hpp
-  include/mock/mock_io.hpp
+  include/mock/mock_log_receiver.hpp
   include/mock/mock_lsg_server.hpp
   include/mock/mock_tcp_server.hpp
   include/temp_file.hpp
@@ -42,7 +42,6 @@ set(
   src/log_tests.cpp
   src/metadata_tests.cpp
   src/mock_http_server.cpp
-  src/mock_io.cpp
   src/mock_lsg_server.cpp
   src/mock_tcp_server.cpp
   src/record_tests.cpp

tests/include/mock/mock_http_server.hpp

@@ -3,10 +3,12 @@
 #include <httplib.h>
 #include <nlohmann/json.hpp>
 
+#include <cstddef>
 #include <map>
 #include <string>
 
 #include "databento/detail/scoped_thread.hpp"
+#include "databento/record.hpp"
 
 namespace databento::tests::mock {
 class MockHttpServer {
@@ -35,6 +37,13 @@ class MockHttpServer {
   void MockStreamDbn(const std::string& path,
                      const std::map<std::string, std::string>& params,
                      const std::string& dbn_path);
+  void MockStreamDbn(const std::string& path,
+                     const std::map<std::string, std::string>& params,
+                     Record record, std::size_t count, std::size_t chunk_size);
+  void MockStreamDbn(const std::string& path,
+                     const std::map<std::string, std::string>& params,
+                     Record record, std::size_t count, std::size_t extra_bytes,
+                     std::size_t chunk_size);
 
  private:
   static void CheckParams(const std::map<std::string, std::string>& params,

tests/include/mock/mock_io.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <gtest/gtest.h>
+
+#include <cstddef>
+#include <functional>
+#include <utility>
+
+#include "databento/log.hpp"
+
+namespace databento::tests::mock {
+class MockLogReceiver : public databento::ILogReceiver {
+ public:
+  using LogCallback =
+      std::function<void(std::size_t, databento::LogLevel, const std::string&)>;
+
+  explicit MockLogReceiver(LogCallback callback)
+      : MockLogReceiver{LogLevel::Info, std::move(callback)} {}
+  MockLogReceiver(LogLevel min_level, LogCallback callback)
+      : callback_{std::move(callback)}, min_level_{min_level} {}
+
+  static MockLogReceiver AssertNoLogs(databento::LogLevel min_level) {
+    return MockLogReceiver{
+        min_level,
+        [min_level](auto, databento::LogLevel level, const std::string& msg) {
+          FAIL() << "Received unexpected log message with level " << level
+                 << ": " << msg;
+        }};
+  }
+
+  void Receive(databento::LogLevel level, const std::string& msg) override {
+    if (level >= min_level_) {
+      callback_(call_count_, level, msg);
+      ++call_count_;
+    }
+  }
+
+  bool ShouldLog(databento::LogLevel level) const override {
+    return level >= min_level_;
+  }
+
+  std::size_t CallCount() const { return call_count_; }
+
+ private:
+  LogCallback callback_;
+  LogLevel min_level_{};
+  std::size_t call_count_{};
+};
+}  // namespace databento::tests::mock