react-native-tvos 0.74.3-0 → 0.75.2-0

package/ReactCommon/jsinspector-modern/tests/ConsoleApiTest.cpp

@@ -0,0 +1,851 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <folly/executors/QueuedImmediateExecutor.h>
+#include "JsiIntegrationTest.h"
+
+#include "engines/JsiIntegrationTestHermesEngineAdapter.h"
+#include "prelude.js.h"
+
+#include <utility>
+
+using namespace ::testing;
+
+namespace facebook::react::jsinspector_modern {
+
+namespace {
+
+struct Params {
+  /**
+   * Whether to evaluate the prelude.js script (containing RN's console
+   * polyfill) after setting up the Runtime.
+   */
+  bool withConsolePolyfill{false};
+
+  /**
+   * Whether to install the global nativeLoggingHook function after setting up
+   * the Runtime (before the prelude if any).
+   */
+  bool withNativeLoggingHook{false};
+
+  /**
+   * Whether to enable the Runtime domain at the start of the test (and expect
+   * live consoleAPICalled notifications), or enable it at the *end* of the test
+   * (and expect buffered notifications at that point).
+   */
+  bool runtimeEnabledAtStart{false};
+};
+
+} // namespace
+
+/**
+ * A test fixture for the Console API.
+ */
+class ConsoleApiTest : public JsiIntegrationPortableTestBase<
+                           JsiIntegrationTestHermesEngineAdapter,
+                           folly::QueuedImmediateExecutor>,
+                       public WithParamInterface<Params> {
+ protected:
+  void SetUp() override {
+    JsiIntegrationPortableTestBase::SetUp();
+    connect();
+    EXPECT_CALL(
+        fromPage(),
+        onMessage(
+            JsonParsed(AllOf(AtJsonPtr("/method", "Debugger.scriptParsed")))))
+        .Times(AnyNumber())
+        .WillRepeatedly(Invoke<>([this](std::string message) {
+          auto params = folly::parseJson(message);
+          // Store the script ID and URL for later use.
+          scriptUrlsById_.emplace(
+              params.at("params").at("scriptId").getString(),
+              params.at("params").at("url").getString());
+        }));
+    this->expectMessageFromPage(JsonEq(R"({
+                                            "id": 0,
+                                            "result": {}
+                                        })"));
+    this->toPage_->sendMessage(R"({
+                                    "id": 0,
+                                    "method": "Debugger.enable"
+                                })");
+
+    if (GetParam().runtimeEnabledAtStart) {
+      enableRuntimeDomain();
+    }
+  }
+
+  void TearDown() override {
+    if (!GetParam().runtimeEnabledAtStart) {
+      enableRuntimeDomain();
+    }
+    JsiIntegrationPortableTestBase::TearDown();
+  }
+
+  /**
+   * Expect a console API call to be reported with parameters matching \param
+   * paramsMatcher.
+   */
+  void expectConsoleApiCall(Matcher<folly::dynamic> paramsMatcher) {
+    if (runtimeEnabled_) {
+      expectConsoleApiCallImpl(std::move(paramsMatcher));
+    } else {
+      expectedConsoleApiCalls_.emplace_back(paramsMatcher);
+    }
+  }
+
+  /**
+   * Expect a console API call to be reported with parameters matching \param
+   * paramsMatcher, only if the Runtime domain is currently enabled ( = the call
+   * is reported in real time).
+   */
+  void expectConsoleApiCallImmediate(Matcher<folly::dynamic> paramsMatcher) {
+    if (runtimeEnabled_) {
+      expectConsoleApiCallImpl(std::move(paramsMatcher));
+    }
+  }
+
+  /**
+   * Expect a console API call to be reported with parameters matching \param
+   * paramsMatcher, only if the Runtime domain is currently disabled ( = the
+   * call will be buffered and reported later upon enabling the domain).
+   */
+  void expectConsoleApiCallBuffered(Matcher<folly::dynamic> paramsMatcher) {
+    if (!runtimeEnabled_) {
+      expectedConsoleApiCalls_.emplace_back(paramsMatcher);
+    }
+  }
+
+  bool isRuntimeDomainEnabled() const {
+    return runtimeEnabled_;
+  }
+
+  void clearExpectedConsoleApiCalls() {
+    expectedConsoleApiCalls_.clear();
+  }
+
+  template <typename InnerMatcher>
+  Matcher<folly::dynamic> ScriptIdMapsTo(InnerMatcher urlMatcher) {
+    return ResultOf(
+        [this](const auto& id) { return getScriptUrlById(id.getString()); },
+        urlMatcher);
+  }
+
+ private:
+  std::optional<std::string> getScriptUrlById(std::string scriptId) {
+    auto it = scriptUrlsById_.find(scriptId);
+    if (it == scriptUrlsById_.end()) {
+      return std::nullopt;
+    }
+    return it->second;
+  }
+
+  void expectConsoleApiCallImpl(Matcher<folly::dynamic> paramsMatcher) {
+    this->expectMessageFromPage(JsonParsed(AllOf(
+        AtJsonPtr("/method", "Runtime.consoleAPICalled"),
+        AtJsonPtr("/params", std::move(paramsMatcher)))));
+  }
+
+  void enableRuntimeDomain() {
+    InSequence s;
+    auto executionContextInfo = this->expectMessageFromPage(JsonParsed(
+        AllOf(AtJsonPtr("/method", "Runtime.executionContextCreated"))));
+    if (!runtimeEnabled_) {
+      for (auto& call : expectedConsoleApiCalls_) {
+        expectConsoleApiCallImpl(call);
+      }
+      expectedConsoleApiCalls_.clear();
+    }
+    this->expectMessageFromPage(JsonEq(R"({
+                                            "id": 1,
+                                            "result": {}
+                                        })"));
+    this->toPage_->sendMessage(R"({
+                                    "id": 1,
+                                    "method": "Runtime.enable"
+                                })");
+
+    ASSERT_TRUE(executionContextInfo->has_value());
+
+    runtimeEnabled_ = true;
+  }
+
+  void loadMainBundle() override {
+    auto params = GetParam();
+    if (params.withNativeLoggingHook) {
+      // The presence or absence of nativeLoggingHook affects the console
+      // polyfill's behaviour.
+      eval(
+          R"(
+            if (!globalThis.nativeLoggingHook) {
+              globalThis.nativeLoggingHook = function(level, message) {
+                print(level + ': ' + message);
+              };
+            }
+          )");
+    } else {
+      // Ensure that we run without nativeLoggingHook even if it was installed
+      // elsewhere.
+      eval(R"(
+        delete globalThis.nativeLoggingHook;
+      )");
+    }
+    if (params.withConsolePolyfill) {
+      eval(preludeJsCode);
+    }
+  }
+
+  std::vector<Matcher<folly::dynamic>> expectedConsoleApiCalls_;
+  bool runtimeEnabled_{false};
+  std::unordered_map<std::string, std::string> scriptUrlsById_;
+};
+
+class ConsoleApiTestWithPreExistingConsole : public ConsoleApiTest {
+  void setupRuntimeBeforeRegistration(jsi::Runtime& /*unused*/) override {
+    eval(R"(
+      globalThis.__console_messages__ = [];
+      globalThis.console = {
+        log: function(...args) {
+          globalThis.__console_messages__.push({
+            type: 'log',
+            args,
+          });
+        },
+        warn: function(...args) {
+          globalThis.__console_messages__.push({
+            type: 'warn',
+            args,
+          });
+        },
+      };
+    )");
+  }
+};
+
+TEST_P(ConsoleApiTest, testConsoleLog) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "log"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                   "type": "string",
+                   "value": "hello"
+                 }, {
+                   "type": "string",
+                   "value": "world"
+                 }])"_json)));
+  eval("console.log('hello', 'world');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleDebug) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "debug"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "hello fusebox"
+              }])"_json)));
+  eval("console.debug('hello fusebox');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleInfo) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "info"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "you should know this"
+              }])"_json)));
+  eval("console.info('you should know this');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleError) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "error"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "uh oh"
+              }])"_json)));
+  eval("console.error('uh oh');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleWarn) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "careful"
+              }])"_json)));
+  eval("console.warn('careful');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleDir) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "dir"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "something"
+              }])"_json)));
+  eval("console.dir('something');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleDirxml) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "dirxml"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "pretend this is a DOM element"
+              }])"_json)));
+  eval("console.dirxml('pretend this is a DOM element');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleTable) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "table"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "pretend this is a complex object"
+              }])"_json)));
+  eval("console.table('pretend this is a complex object');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleTrace) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "trace"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "trace trace"
+              }])"_json)));
+  eval("console.trace('trace trace');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleClear) {
+  InSequence s;
+  expectConsoleApiCall(
+      AllOf(AtJsonPtr("/type", "clear"), AtJsonPtr("/args", "[]"_json)));
+  eval("console.clear();");
+}
+
+TEST_P(ConsoleApiTest, testConsoleClearAfterOtherCall) {
+  InSequence s;
+  if (isRuntimeDomainEnabled()) {
+    // This should only be delivered if console notifications are enabled, not
+    // when they're being cached for later.
+    expectConsoleApiCall(AllOf(
+        AtJsonPtr("/type", "log"),
+        AtJsonPtr(
+            "/args",
+            R"([{
+                  "type": "string",
+                  "value": "hello"
+                }])"_json)));
+  }
+  expectConsoleApiCall(
+      AllOf(AtJsonPtr("/type", "clear"), AtJsonPtr("/args", "[]"_json)));
+  eval("console.log('hello');");
+  eval("console.clear();");
+}
+
+TEST_P(ConsoleApiTest, testConsoleGroup) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "startGroup"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "group title"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "log"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "in group"
+              }])"_json)));
+  expectConsoleApiCall(
+      AllOf(AtJsonPtr("/type", "endGroup"), AtJsonPtr("/args", "[]"_json)));
+  eval("console.group('group title');");
+  eval("console.log('in group');");
+  eval("console.groupEnd();");
+}
+
+TEST_P(ConsoleApiTest, testConsoleGroupCollapsed) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "startGroupCollapsed"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "group collapsed title"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "log"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "in group collapsed"
+              }])"_json)));
+  expectConsoleApiCall(
+      AllOf(AtJsonPtr("/type", "endGroup"), AtJsonPtr("/args", "[]"_json)));
+  eval("console.groupCollapsed('group collapsed title');");
+  eval("console.log('in group collapsed');");
+  eval("console.groupEnd();");
+}
+
+TEST_P(ConsoleApiTest, testConsoleAssert) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "assert"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Assertion failed: something is bad"
+              }])"_json)));
+  eval("console.assert(true, 'everything is good');");
+  eval("console.assert(false, 'something is bad');");
+
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "assert"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Assertion failed"
+              }])"_json)));
+  eval("console.assert();");
+}
+
+TEST_P(ConsoleApiTest, testConsoleCount) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "default: 1"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "default: 2"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "default: 3"
+              }])"_json)));
+  eval("console.count();");
+  eval("console.count('default');");
+  eval("console.count();");
+  eval("console.countReset();");
+
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "default: 1"
+              }])"_json)));
+  eval("console.count();");
+  eval("console.countReset('default');");
+
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "default: 1"
+              }])"_json)));
+  eval("console.count();");
+}
+
+TEST_P(ConsoleApiTest, testConsoleCountLabel) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "foo: 1"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "foo: 2"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "foo: 3"
+              }])"_json)));
+  eval("console.count('foo');");
+  eval("console.count('foo');");
+  eval("console.count('foo');");
+  eval("console.countReset('foo');");
+
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "count"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "foo: 1"
+              }])"_json)));
+  eval("console.count('foo');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleCountResetInvalidLabel) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Count for 'default' does not exist"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Count for 'default' does not exist"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Count for 'foo' does not exist"
+              }])"_json)));
+  eval("console.countReset();");
+  eval("console.countReset('default');");
+  eval("console.countReset('foo');");
+}
+
+// TODO(moti): Tests for console.timeEnd() and timeLog() that actually check the
+// output (with mocked system clock?)
+
+TEST_P(ConsoleApiTest, testConsoleTimeExistingLabel) {
+  eval("console.time();");
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Timer 'default' already exists"
+              }])"_json)));
+  eval("console.time('default');");
+
+  eval("console.time('foo');");
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Timer 'foo' already exists"
+              }])"_json)));
+  eval("console.time('foo');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleTimeInvalidLabel) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Timer 'default' does not exist"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Timer 'default' does not exist"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Timer 'foo' does not exist"
+              }])"_json)));
+  eval("console.timeEnd();");
+  eval("console.timeEnd('default');");
+  eval("console.timeEnd('foo');");
+
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Timer 'default' does not exist"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Timer 'default' does not exist"
+              }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "Timer 'foo' does not exist"
+              }])"_json)));
+  eval("console.timeLog();");
+  eval("console.timeLog('default');");
+  eval("console.timeLog('foo');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleSilentlyClearedOnReload) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "log"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "hello"
+              }])"_json)));
+  eval("console.log('hello');");
+
+  // If there are any expectations we haven't checked yet, clear them
+  clearExpectedConsoleApiCalls();
+  // Reloading generates some Runtime events
+  if (isRuntimeDomainEnabled()) {
+    expectMessageFromPage(JsonParsed(
+        AllOf(AtJsonPtr("/method", "Runtime.executionContextDestroyed"))));
+    expectMessageFromPage(JsonParsed(
+        AllOf(AtJsonPtr("/method", "Runtime.executionContextsCleared"))));
+    expectMessageFromPage(JsonParsed(
+        AllOf(AtJsonPtr("/method", "Runtime.executionContextCreated"))));
+  }
+  reload();
+
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "log"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "world"
+              }])"_json)));
+  eval("console.log('world');");
+}
+
+TEST_P(ConsoleApiTestWithPreExistingConsole, testPreExistingConsoleObject) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "log"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+              "type": "string",
+              "value": "hello"
+            }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "warning"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+              "type": "string",
+              "value": "world"
+            }])"_json)));
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "table"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+              "type": "number",
+              "value": 42
+            }])"_json)));
+  eval("console.log('hello');");
+  eval("console.warn('world');");
+  // NOTE: not present in the pre-existing console object
+  eval("console.table(42);");
+  auto& runtime = engineAdapter_->getRuntime();
+  EXPECT_THAT(
+      eval("JSON.stringify(globalThis.__console_messages__)")
+          .asString(runtime)
+          .utf8(runtime),
+      JsonEq(
+          R"([{
+            "type": "log",
+            "args": [
+              "hello"
+            ]
+          }, {
+            "type": "warn",
+            "args": [
+              "world"
+            ]
+          }])"));
+}
+
+TEST_P(ConsoleApiTest, testConsoleLogStack) {
+  InSequence s;
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "log"),
+      AtJsonPtr(
+          "/args",
+          R"([{
+                "type": "string",
+                "value": "hello"
+              }])"_json),
+      AtJsonPtr(
+          "/stackTrace/callFrames",
+          AllOf(
+              Each(AtJsonPtr(
+                  "/url",
+                  Conditional(
+                      GetParam().withConsolePolyfill,
+                      AnyOf("script.js", "prelude.js"),
+                      "script.js"))),
+              // A relatively weak assertion: we expect at least one frame tying
+              // the call to the `console.log` line.
+              Contains(AllOf(
+                  AtJsonPtr("/functionName", "global"),
+                  AtJsonPtr("/url", "script.js"),
+                  AtJsonPtr("/lineNumber", 1),
+                  AtJsonPtr("/scriptId", ScriptIdMapsTo("script.js"))))))));
+  eval(R"( // line 0
+    console.log('hello'); // line 1
+    //# sourceURL=script.js
+  )");
+}
+
+TEST_P(ConsoleApiTest, testConsoleLogTwice) {
+  InSequence s;
+  expectConsoleApiCall(
+      AllOf(AtJsonPtr("/type", "log"), AtJsonPtr("/args/0/value", "hello")));
+  eval("console.log('hello');");
+  expectConsoleApiCall(AllOf(
+      AtJsonPtr("/type", "log"), AtJsonPtr("/args/0/value", "hello again")));
+  eval("console.log('hello again');");
+}
+
+TEST_P(ConsoleApiTest, testConsoleLogWithObjectPreview) {
+  InSequence s;
+  expectConsoleApiCallImmediate(AllOf(
+      AtJsonPtr("/type", "log"),
+      AtJsonPtr("/args/0/preview/type", "object"),
+      AtJsonPtr("/args/0/preview/overflow", false),
+      AtJsonPtr("/args/0/preview/properties/0/name", "string"),
+      AtJsonPtr("/args/0/preview/properties/0/type", "string"),
+      AtJsonPtr("/args/0/preview/properties/0/value", "hello")));
+  expectConsoleApiCallBuffered(AllOf(AtJsonPtr("/type", "log")));
+  eval("console.log({ string: 'hello' });");
+}
+
+static const auto paramValues = testing::Values(
+    Params{
+        .withConsolePolyfill = true,
+        .withNativeLoggingHook = false,
+        .runtimeEnabledAtStart = false,
+    },
+    Params{
+        .withConsolePolyfill = false,
+        .withNativeLoggingHook = false,
+        .runtimeEnabledAtStart = false,
+    },
+    Params{
+        .withConsolePolyfill = true,
+        .withNativeLoggingHook = false,
+        .runtimeEnabledAtStart = true,
+    },
+    Params{
+        .withConsolePolyfill = false,
+        .withNativeLoggingHook = false,
+        .runtimeEnabledAtStart = true,
+    },
+    Params{
+        .withConsolePolyfill = true,
+        .withNativeLoggingHook = true,
+        .runtimeEnabledAtStart = false,
+    },
+    Params{
+        .withConsolePolyfill = false,
+        .withNativeLoggingHook = true,
+        .runtimeEnabledAtStart = false,
+    },
+    Params{
+        .withConsolePolyfill = true,
+        .withNativeLoggingHook = true,
+        .runtimeEnabledAtStart = true,
+    },
+    Params{
+        .withConsolePolyfill = false,
+        .withNativeLoggingHook = true,
+        .runtimeEnabledAtStart = true,
+    });
+
+INSTANTIATE_TEST_SUITE_P(ConsoleApiTest, ConsoleApiTest, paramValues);
+
+INSTANTIATE_TEST_SUITE_P(
+    ConsoleApiTestWithPreExistingConsole,
+    ConsoleApiTestWithPreExistingConsole,
+    paramValues);
+
+} // namespace facebook::react::jsinspector_modern