From a41515b8eb7c8fd65bfa5e1affc00a32844491f6 Mon Sep 17 00:00:00 2001
From: Nanaloveyuki <miaomiao_159@outlook.com>
Date: Sun, 14 Jun 2026 03:15:44 +0800
Subject: [PATCH] :white_check_mark: cover library async write facade

---
 src-async/BitLoggerAsync_test.mbt | 105 ++++++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)

diff --git a/src-async/BitLoggerAsync_test.mbt b/src-async/BitLoggerAsync_test.mbt
index 86655d7..84f2336 100644
--- a/src-async/BitLoggerAsync_test.mbt
+++ b/src-async/BitLoggerAsync_test.mbt
@@ -645,6 +645,111 @@ async test "library async logger child composes target through facade" {
   inspect(keep_parent.to_async_logger().target, content="sdk")
 }
 
+async test "library async logger log supports per-call target override" {
+  let written_target : Ref[String] = Ref("")
+  let written_message : Ref[String] = Ref("")
+  let written_fields : Ref[Array[@bitlogger.Field]] = Ref([])
+  let logger = LibraryAsyncLogger::new(
+    @bitlogger.callback_sink(fn(rec) {
+      written_target.val = rec.target
+      written_message.val = rec.message
+      written_fields.val = rec.fields
+    }),
+    config=AsyncLoggerConfig::new(max_pending=4),
+    min_level=@bitlogger.Level::Warn,
+    target="async.lib.default",
+  )
+    .with_context_fields([@bitlogger.field("service", "bitlogger")])
+
+  @async.with_task_group(group => {
+    group.spawn_bg(() => logger.run())
+    logger.log(
+      @bitlogger.Level::Error,
+      "override",
+      fields=[@bitlogger.field("mode", "test")],
+      target="async.lib.override",
+    )
+    logger.shutdown()
+  })
+
+  inspect(written_target.val, content="async.lib.override")
+  inspect(written_message.val, content="override")
+  inspect(written_fields.val.length(), content="2")
+  inspect(written_fields.val[0].key, content="service")
+  inspect(written_fields.val[0].value, content="bitlogger")
+  inspect(written_fields.val[1].key, content="mode")
+  inspect(written_fields.val[1].value, content="test")
+
+  let second_target : Ref[String] = Ref("")
+  let second_message : Ref[String] = Ref("")
+  let second_fields : Ref[Array[@bitlogger.Field]] = Ref([])
+  let second = LibraryAsyncLogger::new(
+    @bitlogger.callback_sink(fn(rec) {
+      second_target.val = rec.target
+      second_message.val = rec.message
+      second_fields.val = rec.fields
+    }),
+    config=AsyncLoggerConfig::new(max_pending=4),
+    min_level=@bitlogger.Level::Warn,
+    target="async.lib.default",
+  )
+    .with_context_fields([@bitlogger.field("service", "bitlogger")])
+
+  @async.with_task_group(group => {
+    group.spawn_bg(() => second.run())
+    second.log(@bitlogger.Level::Error, "default")
+    second.shutdown()
+  })
+
+  inspect(second_target.val, content="async.lib.default")
+  inspect(second_message.val, content="default")
+  inspect(second_fields.val.length(), content="1")
+  inspect(second_fields.val[0].key, content="service")
+}
+
+async test "library async severity helpers use stored target without override" {
+  let written_levels : Ref[Array[String]] = Ref([])
+  let written_targets : Ref[Array[String]] = Ref([])
+  let written_fields : Ref[Array[Array[@bitlogger.Field]]] = Ref([])
+  let logger = LibraryAsyncLogger::new(
+    @bitlogger.callback_sink(fn(rec) {
+      written_levels.val.push(rec.level.label())
+      written_targets.val.push(rec.target)
+      written_fields.val.push(rec.fields)
+    }),
+    config=AsyncLoggerConfig::new(max_pending=4),
+    min_level=@bitlogger.Level::Info,
+    target="async.lib.helpers",
+  )
+    .bind([@bitlogger.field("service", "bitlogger")])
+
+  @async.with_task_group(group => {
+    group.spawn_bg(() => logger.run())
+    logger.info("info", fields=[@bitlogger.field("mode", "info")])
+    logger.warn("warn", fields=[@bitlogger.field("mode", "warn")])
+    logger.error("error", fields=[@bitlogger.field("mode", "error")])
+    logger.shutdown()
+  })
+
+  inspect(written_levels.val.length(), content="3")
+  inspect(written_levels.val[0], content="INFO")
+  inspect(written_levels.val[1], content="WARN")
+  inspect(written_levels.val[2], content="ERROR")
+  inspect(written_targets.val.length(), content="3")
+  inspect(written_targets.val[0], content="async.lib.helpers")
+  inspect(written_targets.val[1], content="async.lib.helpers")
+  inspect(written_targets.val[2], content="async.lib.helpers")
+  inspect(written_fields.val[0].length(), content="2")
+  inspect(written_fields.val[1].length(), content="2")
+  inspect(written_fields.val[2].length(), content="2")
+  inspect(written_fields.val[0][0].key, content="service")
+  inspect(written_fields.val[0][1].value, content="info")
+  inspect(written_fields.val[1][0].key, content="service")
+  inspect(written_fields.val[1][1].value, content="warn")
+  inspect(written_fields.val[2][0].key, content="service")
+  inspect(written_fields.val[2][1].value, content="error")
+}
+
 async test "library async shutdown preserves wrapped failure cleanup semantics" {
   let writes : Ref[Int] = Ref(0)
   let logger = LibraryAsyncLogger::new(