Updated unit tests

Author: bauer-andreas

Tests/TemporalTests/Worker/Activities/ActivityWorkerTests.swift

@@ -231,17 +231,20 @@ private struct BadHeartbeatAcivity: ActivityDefinition {
     }
 }
 
-private struct ReadingHeartbeatAcivity: ActivityDefinition {
+struct ReadingHeartbeatActivity: ActivityDefinition {
     struct HeartbeatDetails: Codable, Hashable {
         var string: String
         var data: Data
     }
     typealias Input = Void
-    typealias Output = HeartbeatDetails
+    typealias Output = HeartbeatDetails?
 
-    static let name: String? = "ReadingHeartbeatAcivity"
+    static let name: String? = "ReadingHeartbeatActivity"
 
-    func run(input: Void) async throws -> HeartbeatDetails {
+    func run(input: Void) async throws -> HeartbeatDetails? {
+        guard ActivityExecutionContext.current!.info.hasHeartbeatDetails else {
+            return nil
+        }
         let (string, data) = try await ActivityExecutionContext.current!.info.heartbeatDetails(
             as: String.self,
             Data.self
@@ -748,9 +751,9 @@ struct ActivityWorkerTests {
         }
     }
 
-    @Test
-    static func readingHeartbeat() async throws {
-        let test = ActivityWorkerTests(activities: [ReadingHeartbeatAcivity()])
+    @Test("Read Heartbeat Details", arguments: [true, false])
+    static func readingHeartbeat(heartbeatDetailsAvailable: Bool) async throws {
+        let test = ActivityWorkerTests(activities: [ReadingHeartbeatActivity()])
 
         try await withThrowingTaskGroup(of: Void.self) { group in
             group.addTask {
@@ -760,40 +763,47 @@ struct ActivityWorkerTests {
             test.bridgeWorker.activityTaskContinuation.yield(
                 .with {
                     $0.taskToken = Data([1])
-                    $0.start.activityType = "ReadingHeartbeatAcivity"
+                    $0.start.activityType = "ReadingHeartbeatActivity"
                     $0.start.activityID = "ActivityID1"
                     $0.start.attempt = 1
                     $0.start.workflowType = "WorkflowType"
                     $0.start.workflowExecution = .with {
                         $0.runID = "RunID"
                         $0.workflowID = "WorkflowID1"
                     }
-                    $0.start.heartbeatDetails = [
-                        .with {
-                            $0.data = Data(#""Foo""#.utf8)
-                            $0.metadata = ["encoding": Data("json/plain".utf8)]
-                        },
-                        .with {
-                            $0.data = Data([1, 2, 3])
-                            $0.metadata = ["encoding": Data("binary/plain".utf8)]
-                        },
-                    ]
+                    if heartbeatDetailsAvailable {
+                        $0.start.heartbeatDetails = [
+                            .with {
+                                $0.data = Data(#""Foo""#.utf8)
+                                $0.metadata = ["encoding": Data("json/plain".utf8)]
+                            },
+                            .with {
+                                $0.data = Data([1, 2, 3])
+                                $0.metadata = ["encoding": Data("binary/plain".utf8)]
+                            },
+                        ]
+                    }
                 }
             )
 
             var activityTaskCompletionIterator = test.bridgeWorker.activityTaskCompletionStream.makeAsyncIterator()
             let completion = try await activityTaskCompletionIterator.next()
             #expect(completion?.taskToken == Data([1]))
             let jsonDecoder = JSONDecoder()
-            let expectedHeartbeatDetails = ReadingHeartbeatAcivity.HeartbeatDetails(
-                string: "Foo",
-                data: Data([1, 2, 3])
-            )
             let heartbeatDetails = try jsonDecoder.decode(
-                ReadingHeartbeatAcivity.HeartbeatDetails.self,
+                (ReadingHeartbeatActivity.HeartbeatDetails?).self,
                 from: completion!.result.completed.result.data
             )
-            #expect(heartbeatDetails == expectedHeartbeatDetails)
+
+            if heartbeatDetailsAvailable {
+                let expectedHeartbeatDetails = ReadingHeartbeatActivity.HeartbeatDetails(
+                    string: "Foo",
+                    data: Data([1, 2, 3])
+                )
+                #expect(heartbeatDetails == expectedHeartbeatDetails)
+            } else {
+                #expect(heartbeatDetails == nil)
+            }
             group.cancelAll()
         }
     }