=receptionist rdar://97586760 lookup() trying to cast stub actor

Author: ktoso

Sources/DistributedActors/Cluster/Reception/OperationLogDistributedReceptionist.swift

@@ -391,7 +391,7 @@ extension OpLogDistributedReceptionist: LifecycleWatch {
 
         // self.instrumentation.listingPublished(key: message._key, subscribers: 1, registrations: registrations.count) // TODO(distributed): make the instrumentation calls compatible with distributed actor based types
         let guests = Set(registrations.compactMap { versioned in
-            versioned.actor.underlying as? Guest
+            try? Guest.resolve(id: versioned.actor.underlying.id as! ActorID, using: self.actorSystem)
         })
 
         assert(guests.count == registrations.count, """

Sources/DistributedActors/DistributedActor+Internal.swift

@@ -68,10 +68,7 @@ extension DistributedActor where ActorSystem == ClusterSystem {
     }
 }
 
-distributed actor StubDistributedActor {
+internal distributed actor StubDistributedActor {
     typealias ID = ClusterSystem.ActorID
     typealias ActorSystem = ClusterSystem
-
-    // TODO: this is just to prevent a DI crash because of enums without cases and Codable
-    distributed func _noop() {}
 }

Tests/DistributedActorsTests/DistributedReceptionistTests.swift

@@ -220,24 +220,34 @@ final class DistributedReceptionistTests: ClusterSystemXCTestCase {
 
     // ==== ----------------------------------------------------------------------------------------------------------------
 
-//    func test_receptionist_shouldNotRegisterTheSameRefTwice() throws {
-//        let receptionist = SystemReceptionist(ref: try system._spawn("receptionist", self.receptionistBehavior))
-//        let lookupProbe: ActorTestProbe<_Reception.Listing<_ActorRef<String>>> = self.testKit.makeTestProbe()
-//
-//        let ref: _ActorRef<String> = try system._spawn(.anonymous, .receiveMessage { _ in .same })
-//
-//        let key = _Reception.Key(_ActorRef<String>.self, id: "test")
-//
-//        receptionist.checkIn(ref, with: key)
-//        receptionist.checkIn(ref, with: key)
-//
-//        receptionist.lookup(key, replyTo: lookupProbe.ref)
-//
-//        let listing = try lookupProbe.expectMessage()
-//
-//        listing.refs.count.shouldEqual(1)
-//    }
-//
+    func test_receptionist_shouldNotRegisterTheSameRefTwice() async throws {
+        let ref = Forwarder(probe: nil, name: "D", actorSystem: system)
+
+        await system.receptionist.checkIn(ref, with: .forwarders)
+        await system.receptionist.checkIn(ref, with: .forwarders)
+
+        let listing = await system.receptionist.lookup(.forwarders)
+
+        listing.count.shouldEqual(1)
+    }
+
+    func test_receptionist_happyPath_lookup() async throws {
+        let (first, second) = await self.setUpPair() { settings in
+            settings.enabled = true
+        }
+
+        let ref = Forwarder(probe: nil, name: "D", actorSystem: first)
+        await first.receptionist.checkIn(ref, with: .forwarders)
+
+        first.cluster.join(node: second.cluster.uniqueNode.node)
+        try await first.cluster.joined(node: second.cluster.uniqueNode, within: .seconds(30))
+
+        let listing = await second.receptionist.lookup(.forwarders)
+
+        listing.count.shouldEqual(1)
+        listing.first!.id.shouldEqual(ref.id)
+    }
+
 //    func test_receptionist_shouldRemoveAndAddNewSingletonRef() throws {
 //        let receptionist = SystemReceptionist(ref: try system._spawn("receptionist", self.receptionistBehavior))
 //        let lookupProbe: ActorTestProbe<_Reception.Listing<_ActorRef<String>>> = self.testKit.makeTestProbe()