RespondAuthorizeToHost: set UIN for legacy buddy-added ICBM

When finalizing pending auth and the granter session isn't available, build a
synthetic requester session with UIN so the legacy "added" ICQ message isn't
sent with UIN=0. Tighten RespondAuthorizeToHost tests to assert ICBM send.

foodgroup/feedbag.go

@@ -717,45 +717,45 @@ func isASCII(s string) bool {
 	return true
 }
 
-func (s *FeedbagService) authorizeContact(ctx context.Context, from state.IdentScreenName, to state.IdentScreenName, message string) error {
-	recipSess := s.sessionRetriever.RetrieveSession(to)
+func (s *FeedbagService) authorizeContact(ctx context.Context, granter state.IdentScreenName, requester state.IdentScreenName, message string) error {
+	requesterSess := s.sessionRetriever.RetrieveSession(requester)
 
-	if err := s.contactPreAuthorizer.RecordPreAuth(ctx, from, to); err != nil {
+	if err := s.contactPreAuthorizer.RecordPreAuth(ctx, granter, requester); err != nil {
 		if errors.Is(err, state.ErrNoUser) {
-			s.logger.DebugContext(ctx, "user not found", "name", to.String())
+			s.logger.DebugContext(ctx, "user not found", "name", requester.String())
 			return nil
 		}
 		return fmt.Errorf("RecordPreAuth: %w", err)
 	}
 
-	if recipSess == nil {
-		if err := s.sendLegacyAuthMsg(ctx, from, to); err != nil {
+	if requesterSess == nil {
+		if err := s.sendLegacyAuthMsg(ctx, granter, requester); err != nil {
 			return fmt.Errorf("sendLegacyAuthMsg: %w", err)
 		}
 		return nil
 	}
 
-	if cleared, err := s.clearPendingAuth(ctx, from, to); err != nil {
+	if cleared, err := s.clearPendingAuth(ctx, granter, requester); err != nil {
 		return fmt.Errorf("clearPendingAuth: %w", err)
 	} else if cleared {
 		return nil
 	}
 
-	if recipSess.UsesFeedbag() {
-		rel, err := s.relationshipFetcher.Relationship(ctx, from, to)
+	if requesterSess.UsesFeedbag() {
+		rel, err := s.relationshipFetcher.Relationship(ctx, granter, requester)
 		if err != nil {
 			return fmt.Errorf("relationshipFetcher.Relationship: %w", err)
 		}
 		if rel.BlocksYou {
 			return nil
 		}
-		s.messageRelayer.RelayToScreenName(ctx, to, wire.SNACMessage{
+		s.messageRelayer.RelayToScreenName(ctx, requester, wire.SNACMessage{
 			Frame: wire.SNACFrame{
 				FoodGroup: wire.Feedbag,
 				SubGroup:  wire.FeedbagPreAuthorizedBuddy,
 			},
 			Body: wire.SNAC_0x13_0x15_FeedbagPreAuthorizedBuddy{
-				ScreenName: from.String(),
+				ScreenName: granter.String(),
 				Message:    message,
 				Flags:      0,
 			},
@@ -764,7 +764,7 @@ func (s *FeedbagService) authorizeContact(ctx context.Context, from state.IdentS
 	}
 
 	// send legacy ICQ authorization message
-	if err := s.sendLegacyAuthMsg(ctx, from, to); err != nil {
+	if err := s.sendLegacyAuthMsg(ctx, granter, requester); err != nil {
 		return fmt.Errorf("sendLegacyAuthMsg: %w", err)
 	}
 
@@ -821,8 +821,8 @@ func (s *FeedbagService) sendLegacyBuddyAddedMsg(ctx context.Context, from *stat
 	return nil
 }
 
-func (s *FeedbagService) clearPendingAuth(ctx context.Context, from state.IdentScreenName, to state.IdentScreenName) (bool, error) {
-	items, err := s.feedbagManager.Feedbag(ctx, to)
+func (s *FeedbagService) clearPendingAuth(ctx context.Context, granter state.IdentScreenName, requester state.IdentScreenName) (bool, error) {
+	items, err := s.feedbagManager.Feedbag(ctx, requester)
 	if err != nil {
 		return false, fmt.Errorf("failed to fetch feedbag items: %w", err)
 	}
@@ -830,7 +830,7 @@ func (s *FeedbagService) clearPendingAuth(ctx context.Context, from state.IdentS
 	// look for the pending buddy authorization
 	var buddyItem *wire.FeedbagItem
 	for _, item := range items {
-		if item.ClassID == wire.FeedbagClassIdBuddy && item.Name == from.String() {
+		if item.ClassID == wire.FeedbagClassIdBuddy && item.Name == granter.String() {
 			buddyItem = &item
 			break
 		}
@@ -846,13 +846,14 @@ func (s *FeedbagService) clearPendingAuth(ctx context.Context, from state.IdentS
 	})
 
 	updates := []wire.FeedbagItem{*buddyItem}
-	if err = s.feedbagManager.FeedbagUpsert(ctx, to, updates); err != nil {
+	if err = s.feedbagManager.FeedbagUpsert(ctx, requester, updates); err != nil {
 		return false, fmt.Errorf("failed to update feedbag: %w", err)
 	}
 
-	fromSess := s.sessionRetriever.RetrieveSession(from)
-	if fromSess != nil && fromSess.UsesFeedbag() {
-		s.messageRelayer.RelayToScreenName(ctx, from, wire.SNACMessage{
+	// send a "you were added" message to the granter
+	granterSess := s.sessionRetriever.RetrieveSession(granter)
+	if granterSess != nil && granterSess.UsesFeedbag() {
+		s.messageRelayer.RelayToScreenName(ctx, granter, wire.SNACMessage{
 			Frame: wire.SNACFrame{
 				FoodGroup: wire.Feedbag,
 				SubGroup:  wire.FeedbagBuddyAdded,
@@ -864,20 +865,21 @@ func (s *FeedbagService) clearPendingAuth(ctx context.Context, from state.IdentS
 						wire.NewTLVBE(wire.FeedbagTLVVersion, uint16(4)),
 					},
 				},
-				ScreenName: to.String(),
+				ScreenName: requester.String(),
 			},
 		})
 	} else {
-		toSess := state.NewSession()
-		toSess.SetIdentScreenName(to)
-		toSess.SetDisplayScreenName(state.DisplayScreenName(to.String()))
-		if err := s.sendLegacyBuddyAddedMsg(ctx, toSess.AddInstance(), from); err != nil {
+		requesterSess := state.NewSession()
+		requesterSess.SetIdentScreenName(requester)
+		requesterSess.SetDisplayScreenName(state.DisplayScreenName(requester.String()))
+		requesterSess.SetUIN(requester.UIN())
+		if err := s.sendLegacyBuddyAddedMsg(ctx, requesterSess.AddInstance(), granter); err != nil {
 			return false, fmt.Errorf("sendLegacyBuddyAddedMsg: %w", err)
 		}
 	}
 
-	// clear the pending flag on the recipient's buddy entry
-	s.messageRelayer.RelayToScreenName(ctx, to, wire.SNACMessage{
+	// clear the pending flag on the requester's buddy entry
+	s.messageRelayer.RelayToScreenName(ctx, requester, wire.SNACMessage{
 		Frame: wire.SNACFrame{
 			FoodGroup: wire.Feedbag,
 			SubGroup:  wire.FeedbagUpdateItem,
@@ -887,8 +889,8 @@ func (s *FeedbagService) clearPendingAuth(ctx context.Context, from state.IdentS
 		},
 	})
 
-	// tell the recipient that we're friends
-	s.messageRelayer.RelayToScreenName(ctx, to, wire.SNACMessage{
+	// tell the requester that we're friends
+	s.messageRelayer.RelayToScreenName(ctx, requester, wire.SNACMessage{
 		Frame: wire.SNACFrame{
 			FoodGroup: wire.Feedbag,
 			SubGroup:  wire.FeedbagRespondAuthorizeToClient,
@@ -900,16 +902,16 @@ func (s *FeedbagService) clearPendingAuth(ctx context.Context, from state.IdentS
 					wire.NewTLVBE(wire.FeedbagTLVVersion, uint16(2)),
 				},
 			},
-			ScreenName: from.String(),
+			ScreenName: granter.String(),
 			Accepted:   1,
 		},
 	})
 
-	if fromSess != nil {
-		instances := fromSess.Instances()
+	if granterSess != nil {
+		instances := granterSess.Instances()
 		if len(instances) > 0 {
-			// tell the recipient that we're online
-			if err := s.buddyBroadcaster.BroadcastVisibility(ctx, instances[0], []state.IdentScreenName{to}, false); err != nil {
+			// tell the granter that we're online
+			if err := s.buddyBroadcaster.BroadcastVisibility(ctx, instances[0], []state.IdentScreenName{requester}, false); err != nil {
 				s.logger.ErrorContext(ctx, "broadcastBuddyArrived failed", "err", err)
 			}
 		}
@@ -919,11 +921,8 @@ func (s *FeedbagService) clearPendingAuth(ctx context.Context, from state.IdentS
 }
 
 // RespondAuthorizeToHost forwards an authorization response from the user
-// whose authorization was requested to the user who made the authorization
-// request.
-// Right now we send an ICBM request so that responses can work for both ICQ
-// 2000b and ICQ 2001a. This function should eventually only send an ICBM
-// message to non-feedbag clients and SNAC(0x0013,0x001B) to feedbag clients.
+// whose authorization was requested (granter) to the user who made the
+// authorization request (requester).
 func (s *FeedbagService) RespondAuthorizeToHost(ctx context.Context, instance state.IdentScreenName, inFrame wire.SNACFrame, inBody wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost) error {
 	switch inBody.Accepted {
 	case 0:
@@ -942,9 +941,9 @@ func (s *FeedbagService) RespondAuthorizeToHost(ctx context.Context, instance st
 	return nil
 }
 
-func (s *FeedbagService) rejectContact(ctx context.Context, from state.IdentScreenName, to state.IdentScreenName, reason string) error {
-	if toSess := s.sessionRetriever.RetrieveSession(to); toSess != nil && toSess.UsesFeedbag() {
-		s.messageRelayer.RelayToScreenName(ctx, to, wire.SNACMessage{
+func (s *FeedbagService) rejectContact(ctx context.Context, rejecter state.IdentScreenName, requester state.IdentScreenName, reason string) error {
+	if toSess := s.sessionRetriever.RetrieveSession(requester); toSess != nil && toSess.UsesFeedbag() {
+		s.messageRelayer.RelayToScreenName(ctx, requester, wire.SNACMessage{
 			Frame: wire.SNACFrame{
 				FoodGroup: wire.Feedbag,
 				SubGroup:  wire.FeedbagRespondAuthorizeToClient,
@@ -956,7 +955,7 @@ func (s *FeedbagService) rejectContact(ctx context.Context, from state.IdentScre
 						wire.NewTLVBE(wire.FeedbagTLVVersion, uint16(2)),
 					},
 				},
-				ScreenName: from.String(),
+				ScreenName: rejecter.String(),
 				Accepted:   0,
 				Reason:     reason,
 			},
@@ -968,11 +967,11 @@ func (s *FeedbagService) rejectContact(ctx context.Context, from state.IdentScre
 		}
 		snac := wire.SNAC_0x04_0x06_ICBMChannelMsgToHost{
 			ChannelID:  wire.ICBMChannelICQ,
-			ScreenName: to.String(),
+			ScreenName: requester.String(),
 			TLVRestBlock: wire.TLVRestBlock{
 				TLVList: wire.TLVList{
 					wire.NewTLVLE(wire.ICBMTLVData, wire.ICBMCh4Message{
-						UIN:         from.UIN(),
+						UIN:         rejecter.UIN(),
 						MessageType: wire.ICBMMsgTypeAuthDeny,
 						Message:     reason,
 					}),
@@ -981,8 +980,8 @@ func (s *FeedbagService) rejectContact(ctx context.Context, from state.IdentScre
 			},
 		}
 		fromSess := state.NewSession()
-		fromSess.SetIdentScreenName(from)
-		fromSess.SetDisplayScreenName(state.DisplayScreenName(from.String()))
+		fromSess.SetIdentScreenName(rejecter)
+		fromSess.SetDisplayScreenName(state.DisplayScreenName(rejecter.String()))
 		if _, err := s.icbmSender(ctx, fromSess.AddInstance(), frame, snac); err != nil {
 			return fmt.Errorf("could not send ICBM message: %w", err)
 		}

foodgroup/feedbag_test.go

@@ -3516,19 +3516,21 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 		FoodGroup: wire.ICBM,
 		SubGroup:  wire.ICBMChannelMsgToHost,
 	}
+	granter := state.NewIdentScreenName("100001")
+	requester := state.NewIdentScreenName("100003")
 	tests := []struct {
 		// name is the unit test name
 		name string
-		// instance is the client session
-		instance *state.SessionInstance
+		// granterSess is the session instance of the user who accepts / rejects authorization
+		granterSess *state.SessionInstance
+		// requesterSess is the session instance of the user who requested authorization
+		requesterSess *state.Session
 		// bodyIn is the SNAC body sent by the client
 		bodyIn wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost
-		// buddySess is the online session for the recipient, or nil if offline
-		buddySess *state.Session
 		// mockParams is the list of params sent to mocks that satisfy this
 		// method's dependencies
 		mockParams mockParams
-		// expectICBM is true when RespondAuthorizeToHost should route via icbmSender
+		// expectICBM is true when the response is sent via ICBM rather than Feebdag SNACs
 		expectICBM bool
 		// wantHostSNAC is the expected ICBM body when expectICBM is true
 		wantHostSNAC wire.SNAC_0x04_0x06_ICBMChannelMsgToHost
@@ -3536,27 +3538,28 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 		wantErr error
 	}{
 		{
-			name:     "authorization accepted - offline recipient receives legacy ICQ auth OK",
-			instance: newTestInstance("100001", sessOptUIN(100001)),
+			name:          "requester offline: requester receives auth OK",
+			granterSess:   newTestInstance(state.DisplayScreenName(granter.String()), sessOptUIN(granter.UIN())),
+			requesterSess: nil, // offline
 			bodyIn: wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost{
-				ScreenName: "100003",
+				ScreenName: requester.String(),
 				Accepted:   1,
 			},
 			mockParams: mockParams{
 				contactPreAuthorizerParams: contactPreAuthorizerParams{
 					recordPreAuthParams: recordPreAuthParams{
-						{owner: state.NewIdentScreenName("100001"), buddy: state.NewIdentScreenName("100003")},
+						{owner: granter, buddy: requester},
 					},
 				},
 			},
 			expectICBM: true,
 			wantHostSNAC: wire.SNAC_0x04_0x06_ICBMChannelMsgToHost{
 				ChannelID:  wire.ICBMChannelICQ,
-				ScreenName: "100003",
+				ScreenName: requester.String(),
 				TLVRestBlock: wire.TLVRestBlock{
 					TLVList: wire.TLVList{
 						wire.NewTLVLE(wire.ICBMTLVData, wire.ICBMCh4Message{
-							UIN:         100001,
+							UIN:         granter.UIN(),
 							MessageType: wire.ICBMMsgTypeAuthOK,
 						}),
 						wire.NewTLVBE(wire.ICBMTLVStore, []byte{}),
@@ -3565,21 +3568,22 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 			},
 		},
 		{
-			name:     "authorization denied - offline recipient receives legacy ICQ auth deny",
-			instance: newTestInstance("100001", sessOptUIN(100001)),
+			name:          "requester offline: requester receives auth deny",
+			granterSess:   newTestInstance(state.DisplayScreenName(granter.String()), sessOptUIN(granter.UIN())),
+			requesterSess: nil, // offline
 			bodyIn: wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost{
-				ScreenName: "100003",
+				ScreenName: requester.String(),
 				Accepted:   0,
 				Reason:     "I don't know you!",
 			},
 			expectICBM: true,
 			wantHostSNAC: wire.SNAC_0x04_0x06_ICBMChannelMsgToHost{
 				ChannelID:  wire.ICBMChannelICQ,
-				ScreenName: "100003",
+				ScreenName: requester.String(),
 				TLVRestBlock: wire.TLVRestBlock{
 					TLVList: wire.TLVList{
 						wire.NewTLVLE(wire.ICBMTLVData, wire.ICBMCh4Message{
-							UIN:         100001,
+							UIN:         granter.UIN(),
 							MessageType: wire.ICBMMsgTypeAuthDeny,
 							Message:     "I don't know you!",
 						}),
@@ -3589,46 +3593,46 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 			},
 		},
 		{
-			name:     "authorization accepted - feedbag recipient receives FeedbagPreAuthorizedBuddy",
-			instance: newTestInstance("100001", sessOptUIN(100001)),
-			bodyIn: wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost{
-				ScreenName: "100003",
-				Accepted:   1,
-				Reason:     "welcome",
-			},
-			buddySess: func() *state.Session {
+			name:        "requester online: requester is pre-authorized",
+			granterSess: newTestInstance(state.DisplayScreenName(granter.String()), sessOptUIN(granter.UIN())),
+			requesterSess: func() *state.Session {
 				s := state.NewSession()
-				s.SetIdentScreenName(state.NewIdentScreenName("100003"))
+				s.SetIdentScreenName(requester)
 				s.SetUsesFeedbag()
 				return s
 			}(),
+			bodyIn: wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost{
+				ScreenName: requester.String(),
+				Accepted:   1,
+				Reason:     "welcome",
+			},
 			mockParams: mockParams{
 				contactPreAuthorizerParams: contactPreAuthorizerParams{
 					recordPreAuthParams: recordPreAuthParams{
-						{owner: state.NewIdentScreenName("100001"), buddy: state.NewIdentScreenName("100003")},
+						{owner: granter, buddy: requester},
 					},
 				},
 				feedbagManagerParams: feedbagManagerParams{
 					feedbagParams: feedbagParams{
-						{screenName: state.NewIdentScreenName("100003"), results: []wire.FeedbagItem{}},
+						{screenName: requester, results: []wire.FeedbagItem{}},
 					},
 				},
 				relationshipFetcherParams: relationshipFetcherParams{
 					relationshipParams: relationshipParams{
-						{me: state.NewIdentScreenName("100001"), them: state.NewIdentScreenName("100003"), result: state.Relationship{}},
+						{me: granter, them: requester, result: state.Relationship{}},
 					},
 				},
 				messageRelayerParams: messageRelayerParams{
 					relayToScreenNameParams: relayToScreenNameParams{
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							message: wire.SNACMessage{
 								Frame: wire.SNACFrame{
 									FoodGroup: wire.Feedbag,
 									SubGroup:  wire.FeedbagPreAuthorizedBuddy,
 								},
 								Body: wire.SNAC_0x13_0x15_FeedbagPreAuthorizedBuddy{
-									ScreenName: "100001",
+									ScreenName: granter.String(),
 									Message:    "welcome",
 									Flags:      0,
 								},
@@ -3639,32 +3643,32 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 			},
 		},
 		{
-			name:     "authorization accepted - feedbag recipient with pending auth, sender has feedbag: clearPendingAuth feedbag path",
-			instance: newTestInstance("100001", sessOptUIN(100001)),
-			bodyIn: wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost{
-				ScreenName: "100003",
-				Accepted:   1,
-			},
-			buddySess: func() *state.Session {
+			name:        "requester online: pending auth is finalized",
+			granterSess: newTestInstance(state.DisplayScreenName(granter.String()), sessOptUIN(granter.UIN())),
+			requesterSess: func() *state.Session {
 				s := state.NewSession()
-				s.SetIdentScreenName(state.NewIdentScreenName("100003"))
+				s.SetIdentScreenName(requester)
 				s.SetUsesFeedbag()
 				return s
 			}(),
+			bodyIn: wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost{
+				ScreenName: requester.String(),
+				Accepted:   1,
+			},
 			mockParams: mockParams{
 				contactPreAuthorizerParams: contactPreAuthorizerParams{
 					recordPreAuthParams: recordPreAuthParams{
-						{owner: state.NewIdentScreenName("100001"), buddy: state.NewIdentScreenName("100003")},
+						{owner: granter, buddy: requester},
 					},
 				},
 				feedbagManagerParams: feedbagManagerParams{
 					feedbagParams: feedbagParams{
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							results: []wire.FeedbagItem{
 								{
 									ClassID: wire.FeedbagClassIdBuddy,
-									Name:    "100001",
+									Name:    granter.String(),
 									TLVLBlock: wire.TLVLBlock{
 										TLVList: wire.TLVList{
 											wire.NewTLVBE(wire.FeedbagAttributesPending, []byte{}),
@@ -3677,9 +3681,9 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 					feedbagUpsertParams: feedbagUpsertParams{
 						// slices.DeleteFunc returns an empty non-nil slice after removing the pending tag
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							items: []wire.FeedbagItem{
-								{ClassID: wire.FeedbagClassIdBuddy, Name: "100001", TLVLBlock: wire.TLVLBlock{TLVList: wire.TLVList{}}},
+								{ClassID: wire.FeedbagClassIdBuddy, Name: granter.String(), TLVLBlock: wire.TLVLBlock{TLVList: wire.TLVList{}}},
 							},
 						},
 					},
@@ -3687,10 +3691,10 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 				sessionRetrieverParams: sessionRetrieverParams{
 					retrieveSessionParams: retrieveSessionParams{
 						{
-							screenName: state.NewIdentScreenName("100001"),
+							screenName: granter,
 							result: func() *state.Session {
 								s := state.NewSession()
-								s.SetIdentScreenName(state.NewIdentScreenName("100001"))
+								s.SetIdentScreenName(granter)
 								s.SetUsesFeedbag()
 								s.AddInstance()
 								return s
@@ -3701,7 +3705,7 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 				messageRelayerParams: messageRelayerParams{
 					relayToScreenNameParams: relayToScreenNameParams{
 						{
-							screenName: state.NewIdentScreenName("100001"),
+							screenName: granter,
 							message: wire.SNACMessage{
 								Frame: wire.SNACFrame{
 									FoodGroup: wire.Feedbag,
@@ -3714,12 +3718,12 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 											wire.NewTLVBE(wire.FeedbagTLVVersion, uint16(4)),
 										},
 									},
-									ScreenName: "100003",
+									ScreenName: requester.String(),
 								},
 							},
 						},
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							message: wire.SNACMessage{
 								Frame: wire.SNACFrame{
 									FoodGroup: wire.Feedbag,
@@ -3727,13 +3731,13 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 								},
 								Body: wire.SNAC_0x13_0x09_FeedbagUpdateItem{
 									Items: []wire.FeedbagItem{
-										{ClassID: wire.FeedbagClassIdBuddy, Name: "100001", TLVLBlock: wire.TLVLBlock{TLVList: wire.TLVList{}}},
+										{ClassID: wire.FeedbagClassIdBuddy, Name: granter.String(), TLVLBlock: wire.TLVLBlock{TLVList: wire.TLVList{}}},
 									},
 								},
 							},
 						},
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							message: wire.SNACMessage{
 								Frame: wire.SNACFrame{
 									FoodGroup: wire.Feedbag,
@@ -3746,7 +3750,7 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 											wire.NewTLVBE(wire.FeedbagTLVVersion, uint16(2)),
 										},
 									},
-									ScreenName: "100001",
+									ScreenName: granter.String(),
 									Accepted:   1,
 								},
 							},
@@ -3756,8 +3760,8 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 				buddyBroadcasterParams: buddyBroadcasterParams{
 					broadcastVisibilityParams: broadcastVisibilityParams{
 						{
-							from:             state.NewIdentScreenName("100001"),
-							filter:           []state.IdentScreenName{state.NewIdentScreenName("100003")},
+							from:             granter,
+							filter:           []state.IdentScreenName{requester},
 							doSendDepartures: false,
 						},
 					},
@@ -3765,32 +3769,32 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 			},
 		},
 		{
-			name:     "authorization accepted - feedbag recipient with pending auth, sender offline: clearPendingAuth legacy path",
-			instance: newTestInstance("100001", sessOptUIN(100001)),
+			name:        "requester online, granter offline: pending auth is finalized",
+			granterSess: newTestInstance(state.DisplayScreenName(granter.String()), sessOptUIN(granter.UIN())),
 			bodyIn: wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost{
-				ScreenName: "100003",
+				ScreenName: requester.String(),
 				Accepted:   1,
 			},
-			buddySess: func() *state.Session {
+			requesterSess: func() *state.Session {
 				s := state.NewSession()
-				s.SetIdentScreenName(state.NewIdentScreenName("100003"))
+				s.SetIdentScreenName(requester)
 				s.SetUsesFeedbag()
 				return s
 			}(),
 			mockParams: mockParams{
 				contactPreAuthorizerParams: contactPreAuthorizerParams{
 					recordPreAuthParams: recordPreAuthParams{
-						{owner: state.NewIdentScreenName("100001"), buddy: state.NewIdentScreenName("100003")},
+						{owner: granter, buddy: requester},
 					},
 				},
 				feedbagManagerParams: feedbagManagerParams{
 					feedbagParams: feedbagParams{
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							results: []wire.FeedbagItem{
 								{
 									ClassID: wire.FeedbagClassIdBuddy,
-									Name:    "100001",
+									Name:    granter.String(),
 									TLVLBlock: wire.TLVLBlock{
 										TLVList: wire.TLVList{
 											wire.NewTLVBE(wire.FeedbagAttributesPending, []byte{}),
@@ -3802,22 +3806,22 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 					},
 					feedbagUpsertParams: feedbagUpsertParams{
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							items: []wire.FeedbagItem{
-								{ClassID: wire.FeedbagClassIdBuddy, Name: "100001", TLVLBlock: wire.TLVLBlock{TLVList: wire.TLVList{}}},
+								{ClassID: wire.FeedbagClassIdBuddy, Name: granter.String(), TLVLBlock: wire.TLVLBlock{TLVList: wire.TLVList{}}},
 							},
 						},
 					},
 				},
 				sessionRetrieverParams: sessionRetrieverParams{
 					retrieveSessionParams: retrieveSessionParams{
-						{screenName: state.NewIdentScreenName("100001"), result: nil},
+						{screenName: granter, result: nil},
 					},
 				},
 				messageRelayerParams: messageRelayerParams{
 					relayToScreenNameParams: relayToScreenNameParams{
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							message: wire.SNACMessage{
 								Frame: wire.SNACFrame{
 									FoodGroup: wire.Feedbag,
@@ -3825,13 +3829,13 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 								},
 								Body: wire.SNAC_0x13_0x09_FeedbagUpdateItem{
 									Items: []wire.FeedbagItem{
-										{ClassID: wire.FeedbagClassIdBuddy, Name: "100001", TLVLBlock: wire.TLVLBlock{TLVList: wire.TLVList{}}},
+										{ClassID: wire.FeedbagClassIdBuddy, Name: granter.String(), TLVLBlock: wire.TLVLBlock{TLVList: wire.TLVList{}}},
 									},
 								},
 							},
 						},
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							message: wire.SNACMessage{
 								Frame: wire.SNACFrame{
 									FoodGroup: wire.Feedbag,
@@ -3844,7 +3848,7 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 											wire.NewTLVBE(wire.FeedbagTLVVersion, uint16(2)),
 										},
 									},
-									ScreenName: "100001",
+									ScreenName: granter.String(),
 									Accepted:   1,
 								},
 							},
@@ -3855,11 +3859,11 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 			expectICBM: true,
 			wantHostSNAC: wire.SNAC_0x04_0x06_ICBMChannelMsgToHost{
 				ChannelID:  wire.ICBMChannelICQ,
-				ScreenName: "100001",
+				ScreenName: granter.String(),
 				TLVRestBlock: wire.TLVRestBlock{
 					TLVList: wire.TLVList{
 						wire.NewTLVLE(wire.ICBMTLVData, wire.ICBMCh4Message{
-							UIN:         0,
+							UIN:         requester.UIN(),
 							MessageType: wire.ICBMMsgTypeAdded,
 						}),
 						wire.NewTLVBE(wire.ICBMTLVStore, []byte{}),
@@ -3868,16 +3872,16 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 			},
 		},
 		{
-			name:     "authorization denied - feedbag recipient receives FeedbagRespondAuthorizeToClient",
-			instance: newTestInstance("100001", sessOptUIN(100001)),
+			name:        "requester online: requester is denied",
+			granterSess: newTestInstance(state.DisplayScreenName(granter.String()), sessOptUIN(granter.UIN())),
 			bodyIn: wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost{
-				ScreenName: "100003",
+				ScreenName: requester.String(),
 				Accepted:   0,
 				Reason:     "I don't know you!",
 			},
-			buddySess: func() *state.Session {
+			requesterSess: func() *state.Session {
 				s := state.NewSession()
-				s.SetIdentScreenName(state.NewIdentScreenName("100003"))
+				s.SetIdentScreenName(requester)
 				s.SetUsesFeedbag()
 				return s
 			}(),
@@ -3885,7 +3889,7 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 				messageRelayerParams: messageRelayerParams{
 					relayToScreenNameParams: relayToScreenNameParams{
 						{
-							screenName: state.NewIdentScreenName("100003"),
+							screenName: requester,
 							message: wire.SNACMessage{
 								Frame: wire.SNACFrame{
 									FoodGroup: wire.Feedbag,
@@ -3898,7 +3902,7 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 											wire.NewTLVBE(wire.FeedbagTLVVersion, uint16(2)),
 										},
 									},
-									ScreenName: "100001",
+									ScreenName: granter.String(),
 									Accepted:   0,
 									Reason:     "I don't know you!",
 								},
@@ -3914,7 +3918,7 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 			sessionRetriever := newMockSessionRetriever(t)
 			sessionRetriever.EXPECT().
 				RetrieveSession(state.NewIdentScreenName(tt.bodyIn.ScreenName)).
-				Return(tt.buddySess)
+				Return(tt.requesterSess)
 			for _, params := range tt.mockParams.retrieveSessionParams {
 				sessionRetriever.EXPECT().RetrieveSession(params.screenName).Return(params.result)
 			}
@@ -3949,7 +3953,9 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 					Return(params.err)
 			}
 
+			var icbmCallCount int
 			icbmSender := func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*wire.SNACMessage, error) {
+				icbmCallCount++
 				if !tt.expectICBM {
 					t.Fatalf("unexpected icbmSender call")
 				}
@@ -3966,8 +3972,13 @@ func TestFeedbagService_RespondAuthorizeToHost(t *testing.T) {
 			svc.buddyBroadcaster = buddyBroadcaster
 			svc.icbmSender = icbmSender
 
-			haveErr := svc.RespondAuthorizeToHost(context.Background(), tt.instance.IdentScreenName(), wire.SNACFrame{}, tt.bodyIn)
+			haveErr := svc.RespondAuthorizeToHost(context.Background(), tt.granterSess.IdentScreenName(), wire.SNACFrame{}, tt.bodyIn)
 			assert.ErrorIs(t, tt.wantErr, haveErr)
+			if tt.expectICBM {
+				assert.Equal(t, 1, icbmCallCount, "expected icbmSender to be called exactly once")
+			} else {
+				assert.Equal(t, 0, icbmCallCount, "expected icbmSender not to be called")
+			}
 		})
 	}
 }