Mock Scuba Logger

Summary: This diff introduces a mock implementation for the Scuba logger in the Glean Swift client.

Reviewed By: dmpolukhin

Differential Revision: D79433160

fbshipit-source-id: 0f67f537b3965c8fece91b0691a68b01ab02ca17

Author: ivanmurashko

glean/client/swift/JsonServer.cpp

@@ -20,6 +20,11 @@ void JsonServer::setGlassAccess(std::unique_ptr<IGlassAccess> glassAccess) {
   glassAccess_ = std::move(glassAccess);
 }
 
+void JsonServer::setScubaLogger(
+    std::unique_ptr<facebook::glean::swift::ScubaLogger> scubaLogger) {
+  scubaLogger_ = std::move(scubaLogger);
+}
+
 void JsonServer::start(std::istream& input, std::ostream& output) {
   running_ = true;
 

glean/client/swift/JsonServer.h

@@ -27,6 +27,8 @@ class JsonServer {
   JsonServer& operator=(JsonServer&&) = delete;
 
   void setGlassAccess(std::unique_ptr<IGlassAccess> glassAccess);
+  void setScubaLogger(
+      std::unique_ptr<facebook::glean::swift::ScubaLogger> scubaLogger);
   void start(std::istream& input = std::cin, std::ostream& output = std::cout);
   void stop();
 

glean/client/swift/test/JsonServerTest.cpp

@@ -9,20 +9,19 @@
 #include "glean/client/swift/JsonServer.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-#include <chrono>
 #include <memory>
 #include <sstream>
-#include <thread>
 #include "glean/client/swift/test/GlassAccessMock.h"
-
-using ::testing::Return;
+#include "glean/client/swift/test/ScubaLoggerMock.h"
 
 class JsonServerTest : public ::testing::Test {
  protected:
   void SetUp() override {
     // Create JsonServer and set mock GlassAccess
     server_ = std::make_unique<JsonServer>();
     mockGlassAccess_ = std::make_unique<GlassAccessMock>();
+    mockScubaLogger_ =
+        std::make_unique<facebook::glean::swift::ScubaLoggerMock>();
 
     // Set up default expectations for the mock
     protocol::LocationList defaultLocations;
@@ -36,12 +35,16 @@ class JsonServerTest : public ::testing::Test {
         *mockGlassAccess_,
         usrToDefinition(
             "s:12IGFriendsMap0aB4ViewC03mapC0So05MKMapC0CvgAFyXEfU_ADL_AFvp"))
-        .WillByDefault(Return(defaultLocations));
+        .WillByDefault(testing::Return(defaultLocations));
 
     ON_CALL(*mockGlassAccess_, usrToDefinition("unknown_usr"))
-        .WillByDefault(Return(std::nullopt));
+        .WillByDefault(testing::Return(std::nullopt));
+
+    // Store raw pointer before moving to server
+    mockScubaLoggerPtr_ = mockScubaLogger_.get();
 
     server_->setGlassAccess(std::move(mockGlassAccess_));
+    server_->setScubaLogger(std::move(mockScubaLogger_));
   }
 
   void TearDown() override {
@@ -53,6 +56,8 @@ class JsonServerTest : public ::testing::Test {
 
   std::unique_ptr<JsonServer> server_;
   std::unique_ptr<GlassAccessMock> mockGlassAccess_;
+  std::unique_ptr<facebook::glean::swift::ScubaLoggerMock> mockScubaLogger_;
+  facebook::glean::swift::ScubaLoggerMock* mockScubaLoggerPtr_{};
 };
 
 TEST_F(JsonServerTest, USRToDefinitionRequest) {
@@ -76,6 +81,15 @@ TEST_F(JsonServerTest, USRToDefinitionRequest) {
   EXPECT_TRUE(result.find("\"line\":25") != std::string::npos);
   EXPECT_TRUE(result.find("\"character\":4") != std::string::npos);
   EXPECT_TRUE(result.find("\"character\":30") != std::string::npos);
+
+  // Verify ScubaLogger was called with correct parameters
+  mockScubaLoggerPtr_->expectLogRequest(
+      "usrToDefinition",
+      "s:12IGFriendsMap0aB4ViewC03mapC0So05MKMapC0CvgAFyXEfU_ADL_AFvp",
+      facebook::glean::swift::USRType::SWIFT,
+      facebook::glean::swift::Status::SUCCESS,
+      "",
+      "production");
 }
 
 TEST_F(JsonServerTest, USRToDefinitionRequestNoResults) {
@@ -93,6 +107,15 @@ TEST_F(JsonServerTest, USRToDefinitionRequestNoResults) {
   // Verify the response contains expected JSON structure with empty result
   EXPECT_TRUE(result.find("\"id\":2") != std::string::npos);
   EXPECT_TRUE(result.find("\"result\":[]") != std::string::npos);
+
+  // Verify ScubaLogger was called with correct parameters
+  mockScubaLoggerPtr_->expectLogRequest(
+      "clangUSRToDefinition",
+      "unknown_usr",
+      facebook::glean::swift::USRType::UNKNOWN,
+      facebook::glean::swift::Status::NOT_FOUND,
+      "",
+      "production");
 }
 
 TEST_F(JsonServerTest, UnknownMethodRequest) {
@@ -113,6 +136,15 @@ TEST_F(JsonServerTest, UnknownMethodRequest) {
   EXPECT_TRUE(result.find("\"code\":-32601") != std::string::npos);
   EXPECT_TRUE(
       result.find("\"message\":\"Method not found\"") != std::string::npos);
+
+  // Verify ScubaLogger was called with correct parameters
+  mockScubaLoggerPtr_->expectLogRequest(
+      "UnknownMethod",
+      "test",
+      facebook::glean::swift::USRType::UNKNOWN,
+      facebook::glean::swift::Status::FAILED,
+      "Method not found",
+      "production");
 }
 
 TEST_F(JsonServerTest, InvalidJSONRequest) {
@@ -130,4 +162,16 @@ TEST_F(JsonServerTest, InvalidJSONRequest) {
   EXPECT_TRUE(result.find("\"error\"") != std::string::npos);
   EXPECT_TRUE(result.find("\"code\":-32700") != std::string::npos);
   EXPECT_TRUE(result.find("\"message\":\"Parse error:") != std::string::npos);
+
+  // Verify ScubaLogger was called with correct parameters
+  EXPECT_EQ(1, mockScubaLoggerPtr_->logRequestCallCount);
+  EXPECT_EQ("unknown", mockScubaLoggerPtr_->lastMethod);
+  EXPECT_EQ("", mockScubaLoggerPtr_->lastUsr);
+  EXPECT_EQ(
+      facebook::glean::swift::USRType::UNKNOWN,
+      mockScubaLoggerPtr_->lastUsrType);
+  EXPECT_EQ(
+      facebook::glean::swift::Status::FAILED, mockScubaLoggerPtr_->lastStatus);
+  EXPECT_TRUE(mockScubaLoggerPtr_->lastError.find("Parse error:") == 0);
+  EXPECT_EQ("production", mockScubaLoggerPtr_->lastMode);
 }

glean/client/swift/test/ScubaLoggerMock.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <gmock/gmock.h>
+#include "glean/client/swift/ScubaLogger.h"
+
+namespace facebook::glean::swift {
+
+class ScubaLoggerMock : public ScubaLogger {
+ public:
+  mutable int logRequestCallCount = 0;
+  mutable std::string lastMethod;
+  mutable std::string lastUsr;
+  mutable USRType lastUsrType{USRType::UNKNOWN};
+  mutable std::string lastResult;
+  mutable Status lastStatus{Status::FAILED};
+  mutable int64_t lastDuration{};
+  mutable std::string lastError;
+  mutable std::optional<std::string> lastRevision;
+  mutable std::string lastMode;
+
+  void logRequest(
+      facebook::rfe::ScubaData* scubaLogger,
+      const std::string& method,
+      const std::string& usr,
+      USRType usrType,
+      const std::string& result,
+      Status status,
+      int64_t duration,
+      const std::string& error = "",
+      const std::optional<std::string>& revision = std::nullopt,
+      const std::string& mode = "production") override {
+    (void)scubaLogger; // Suppress unused parameter warning
+    // Don't actually log to Scuba, just record the call
+    logRequestCallCount++;
+    lastMethod = method;
+    lastUsr = usr;
+    lastUsrType = usrType;
+    lastResult = result;
+    lastStatus = status;
+    lastDuration = duration;
+    lastError = error;
+    lastRevision = revision;
+    lastMode = mode;
+  }
+
+  // Helper methods for testing
+  void expectLogRequest(
+      const std::string& expectedMethod,
+      const std::string& expectedUsr,
+      USRType expectedUsrType,
+      Status expectedStatus,
+      const std::string& expectedError = "",
+      const std::string& expectedMode = "production") const {
+    EXPECT_EQ(1, logRequestCallCount);
+    EXPECT_EQ(expectedMethod, lastMethod);
+    EXPECT_EQ(expectedUsr, lastUsr);
+    EXPECT_EQ(expectedUsrType, lastUsrType);
+    EXPECT_EQ(expectedStatus, lastStatus);
+    EXPECT_EQ(expectedError, lastError);
+    EXPECT_EQ(expectedMode, lastMode);
+  }
+
+  void reset() {
+    logRequestCallCount = 0;
+    lastMethod.clear();
+    lastUsr.clear();
+    lastUsrType = USRType::UNKNOWN;
+    lastResult.clear();
+    lastStatus = Status::FAILED;
+    lastDuration = 0;
+    lastError.clear();
+    lastRevision = std::nullopt;
+    lastMode.clear();
+  }
+};
+
+} // namespace facebook::glean::swift