fix: regenerate mocks and update tests for ICQ legacy interface changes

foodgroup/icq_test.go

@@ -1467,8 +1467,8 @@ func TestICQService_FullUserInfo(t *testing.T) {
 													ZIP:          "10001",
 													CountryCode:  1,
 													GMTOffset:    5,
-													AuthFlag:     0,
-													WebAware:     1,
+													AuthFlag:     1,
+													WebAware:     0,
 													DCPerms:      0,
 													PublishEmail: wire.ICQUserFlagPublishEmailYes,
 												},

foodgroup/mock_user_manager_manager_test.go

@@ -39,63 +39,6 @@ func (_m *mockUserManager) EXPECT() *mockUserManager_Expecter {
 	return &mockUserManager_Expecter{mock: &_m.Mock}
 }
 
-// DeleteUser provides a mock function for the type mockUserManager
-func (_mock *mockUserManager) DeleteUser(ctx context.Context, screenName state.IdentScreenName) error {
-	ret := _mock.Called(ctx, screenName)
-
-	if len(ret) == 0 {
-		panic("no return value specified for DeleteUser")
-	}
-
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, state.IdentScreenName) error); ok {
-		r0 = returnFunc(ctx, screenName)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// mockUserManager_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser'
-type mockUserManager_DeleteUser_Call struct {
-	*mock.Call
-}
-
-// DeleteUser is a helper method to define mock.On call
-//   - ctx context.Context
-//   - screenName state.IdentScreenName
-func (_e *mockUserManager_Expecter) DeleteUser(ctx interface{}, screenName interface{}) *mockUserManager_DeleteUser_Call {
-	return &mockUserManager_DeleteUser_Call{Call: _e.mock.On("DeleteUser", ctx, screenName)}
-}
-
-func (_c *mockUserManager_DeleteUser_Call) Run(run func(ctx context.Context, screenName state.IdentScreenName)) *mockUserManager_DeleteUser_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 context.Context
-		if args[0] != nil {
-			arg0 = args[0].(context.Context)
-		}
-		var arg1 state.IdentScreenName
-		if args[1] != nil {
-			arg1 = args[1].(state.IdentScreenName)
-		}
-		run(
-			arg0,
-			arg1,
-		)
-	})
-	return _c
-}
-
-func (_c *mockUserManager_DeleteUser_Call) Return(err error) *mockUserManager_DeleteUser_Call {
-	_c.Call.Return(err)
-	return _c
-}
-
-func (_c *mockUserManager_DeleteUser_Call) RunAndReturn(run func(ctx context.Context, screenName state.IdentScreenName) error) *mockUserManager_DeleteUser_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
 // InsertUser provides a mock function for the type mockUserManager
 func (_mock *mockUserManager) InsertUser(ctx context.Context, u state.User) error {
 	ret := _mock.Called(ctx, u)

server/icq_legacy/mock_feedbag_manager_test.go

@@ -106,3 +106,66 @@ func (_c *mockFeedbagManager_Feedbag_Call) RunAndReturn(run func(ctx context.Con
 	_c.Call.Return(run)
 	return _c
 }
+
+// FeedbagUpsert provides a mock function for the type mockFeedbagManager
+func (_mock *mockFeedbagManager) FeedbagUpsert(ctx context.Context, screenName state.IdentScreenName, items []wire.FeedbagItem) error {
+	ret := _mock.Called(ctx, screenName, items)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FeedbagUpsert")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, state.IdentScreenName, []wire.FeedbagItem) error); ok {
+		r0 = returnFunc(ctx, screenName, items)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// mockFeedbagManager_FeedbagUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeedbagUpsert'
+type mockFeedbagManager_FeedbagUpsert_Call struct {
+	*mock.Call
+}
+
+// FeedbagUpsert is a helper method to define mock.On call
+//   - ctx context.Context
+//   - screenName state.IdentScreenName
+//   - items []wire.FeedbagItem
+func (_e *mockFeedbagManager_Expecter) FeedbagUpsert(ctx interface{}, screenName interface{}, items interface{}) *mockFeedbagManager_FeedbagUpsert_Call {
+	return &mockFeedbagManager_FeedbagUpsert_Call{Call: _e.mock.On("FeedbagUpsert", ctx, screenName, items)}
+}
+
+func (_c *mockFeedbagManager_FeedbagUpsert_Call) Run(run func(ctx context.Context, screenName state.IdentScreenName, items []wire.FeedbagItem)) *mockFeedbagManager_FeedbagUpsert_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 state.IdentScreenName
+		if args[1] != nil {
+			arg1 = args[1].(state.IdentScreenName)
+		}
+		var arg2 []wire.FeedbagItem
+		if args[2] != nil {
+			arg2 = args[2].([]wire.FeedbagItem)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *mockFeedbagManager_FeedbagUpsert_Call) Return(err error) *mockFeedbagManager_FeedbagUpsert_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *mockFeedbagManager_FeedbagUpsert_Call) RunAndReturn(run func(ctx context.Context, screenName state.IdentScreenName, items []wire.FeedbagItem) error) *mockFeedbagManager_FeedbagUpsert_Call {
+	_c.Call.Return(run)
+	return _c
+}

server/icq_legacy/mock_legacy_service_test.go

@@ -951,6 +951,69 @@ func (_c *mockLegacyService_NotifyUserOffline_Call) RunAndReturn(run func(ctx co
 	return _c
 }
 
+// NotifyUserOnline provides a mock function for the type mockLegacyService
+func (_mock *mockLegacyService) NotifyUserOnline(ctx context.Context, uin uint32, status uint32) error {
+	ret := _mock.Called(ctx, uin, status)
+
+	if len(ret) == 0 {
+		panic("no return value specified for NotifyUserOnline")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, uint32) error); ok {
+		r0 = returnFunc(ctx, uin, status)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// mockLegacyService_NotifyUserOnline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifyUserOnline'
+type mockLegacyService_NotifyUserOnline_Call struct {
+	*mock.Call
+}
+
+// NotifyUserOnline is a helper method to define mock.On call
+//   - ctx context.Context
+//   - uin uint32
+//   - status uint32
+func (_e *mockLegacyService_Expecter) NotifyUserOnline(ctx interface{}, uin interface{}, status interface{}) *mockLegacyService_NotifyUserOnline_Call {
+	return &mockLegacyService_NotifyUserOnline_Call{Call: _e.mock.On("NotifyUserOnline", ctx, uin, status)}
+}
+
+func (_c *mockLegacyService_NotifyUserOnline_Call) Run(run func(ctx context.Context, uin uint32, status uint32)) *mockLegacyService_NotifyUserOnline_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 uint32
+		if args[1] != nil {
+			arg1 = args[1].(uint32)
+		}
+		var arg2 uint32
+		if args[2] != nil {
+			arg2 = args[2].(uint32)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *mockLegacyService_NotifyUserOnline_Call) Return(err error) *mockLegacyService_NotifyUserOnline_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *mockLegacyService_NotifyUserOnline_Call) RunAndReturn(run func(ctx context.Context, uin uint32, status uint32) error) *mockLegacyService_NotifyUserOnline_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // ProcessContactList provides a mock function for the type mockLegacyService
 func (_mock *mockLegacyService) ProcessContactList(ctx context.Context, req ContactListRequest) (*ContactListResult, error) {
 	ret := _mock.Called(ctx, req)
@@ -2001,6 +2064,258 @@ func (_c *mockLegacyService_SetPassword_Call) RunAndReturn(run func(ctx context.
 	return _c
 }
 
+// UpdateBasicInfo provides a mock function for the type mockLegacyService
+func (_mock *mockLegacyService) UpdateBasicInfo(ctx context.Context, uin uint32, info state.ICQBasicInfo) error {
+	ret := _mock.Called(ctx, uin, info)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateBasicInfo")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQBasicInfo) error); ok {
+		r0 = returnFunc(ctx, uin, info)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// mockLegacyService_UpdateBasicInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBasicInfo'
+type mockLegacyService_UpdateBasicInfo_Call struct {
+	*mock.Call
+}
+
+// UpdateBasicInfo is a helper method to define mock.On call
+//   - ctx context.Context
+//   - uin uint32
+//   - info state.ICQBasicInfo
+func (_e *mockLegacyService_Expecter) UpdateBasicInfo(ctx interface{}, uin interface{}, info interface{}) *mockLegacyService_UpdateBasicInfo_Call {
+	return &mockLegacyService_UpdateBasicInfo_Call{Call: _e.mock.On("UpdateBasicInfo", ctx, uin, info)}
+}
+
+func (_c *mockLegacyService_UpdateBasicInfo_Call) Run(run func(ctx context.Context, uin uint32, info state.ICQBasicInfo)) *mockLegacyService_UpdateBasicInfo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 uint32
+		if args[1] != nil {
+			arg1 = args[1].(uint32)
+		}
+		var arg2 state.ICQBasicInfo
+		if args[2] != nil {
+			arg2 = args[2].(state.ICQBasicInfo)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *mockLegacyService_UpdateBasicInfo_Call) Return(err error) *mockLegacyService_UpdateBasicInfo_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *mockLegacyService_UpdateBasicInfo_Call) RunAndReturn(run func(ctx context.Context, uin uint32, info state.ICQBasicInfo) error) *mockLegacyService_UpdateBasicInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UpdateMoreInfo provides a mock function for the type mockLegacyService
+func (_mock *mockLegacyService) UpdateMoreInfo(ctx context.Context, uin uint32, info state.ICQMoreInfo) error {
+	ret := _mock.Called(ctx, uin, info)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateMoreInfo")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQMoreInfo) error); ok {
+		r0 = returnFunc(ctx, uin, info)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// mockLegacyService_UpdateMoreInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMoreInfo'
+type mockLegacyService_UpdateMoreInfo_Call struct {
+	*mock.Call
+}
+
+// UpdateMoreInfo is a helper method to define mock.On call
+//   - ctx context.Context
+//   - uin uint32
+//   - info state.ICQMoreInfo
+func (_e *mockLegacyService_Expecter) UpdateMoreInfo(ctx interface{}, uin interface{}, info interface{}) *mockLegacyService_UpdateMoreInfo_Call {
+	return &mockLegacyService_UpdateMoreInfo_Call{Call: _e.mock.On("UpdateMoreInfo", ctx, uin, info)}
+}
+
+func (_c *mockLegacyService_UpdateMoreInfo_Call) Run(run func(ctx context.Context, uin uint32, info state.ICQMoreInfo)) *mockLegacyService_UpdateMoreInfo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 uint32
+		if args[1] != nil {
+			arg1 = args[1].(uint32)
+		}
+		var arg2 state.ICQMoreInfo
+		if args[2] != nil {
+			arg2 = args[2].(state.ICQMoreInfo)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *mockLegacyService_UpdateMoreInfo_Call) Return(err error) *mockLegacyService_UpdateMoreInfo_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *mockLegacyService_UpdateMoreInfo_Call) RunAndReturn(run func(ctx context.Context, uin uint32, info state.ICQMoreInfo) error) *mockLegacyService_UpdateMoreInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UpdatePermissions provides a mock function for the type mockLegacyService
+func (_mock *mockLegacyService) UpdatePermissions(ctx context.Context, uin uint32, info state.ICQPermissions) error {
+	ret := _mock.Called(ctx, uin, info)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdatePermissions")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQPermissions) error); ok {
+		r0 = returnFunc(ctx, uin, info)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// mockLegacyService_UpdatePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePermissions'
+type mockLegacyService_UpdatePermissions_Call struct {
+	*mock.Call
+}
+
+// UpdatePermissions is a helper method to define mock.On call
+//   - ctx context.Context
+//   - uin uint32
+//   - info state.ICQPermissions
+func (_e *mockLegacyService_Expecter) UpdatePermissions(ctx interface{}, uin interface{}, info interface{}) *mockLegacyService_UpdatePermissions_Call {
+	return &mockLegacyService_UpdatePermissions_Call{Call: _e.mock.On("UpdatePermissions", ctx, uin, info)}
+}
+
+func (_c *mockLegacyService_UpdatePermissions_Call) Run(run func(ctx context.Context, uin uint32, info state.ICQPermissions)) *mockLegacyService_UpdatePermissions_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 uint32
+		if args[1] != nil {
+			arg1 = args[1].(uint32)
+		}
+		var arg2 state.ICQPermissions
+		if args[2] != nil {
+			arg2 = args[2].(state.ICQPermissions)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *mockLegacyService_UpdatePermissions_Call) Return(err error) *mockLegacyService_UpdatePermissions_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *mockLegacyService_UpdatePermissions_Call) RunAndReturn(run func(ctx context.Context, uin uint32, info state.ICQPermissions) error) *mockLegacyService_UpdatePermissions_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
+// UpdateWorkInfo provides a mock function for the type mockLegacyService
+func (_mock *mockLegacyService) UpdateWorkInfo(ctx context.Context, uin uint32, info state.ICQWorkInfo) error {
+	ret := _mock.Called(ctx, uin, info)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UpdateWorkInfo")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQWorkInfo) error); ok {
+		r0 = returnFunc(ctx, uin, info)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// mockLegacyService_UpdateWorkInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkInfo'
+type mockLegacyService_UpdateWorkInfo_Call struct {
+	*mock.Call
+}
+
+// UpdateWorkInfo is a helper method to define mock.On call
+//   - ctx context.Context
+//   - uin uint32
+//   - info state.ICQWorkInfo
+func (_e *mockLegacyService_Expecter) UpdateWorkInfo(ctx interface{}, uin interface{}, info interface{}) *mockLegacyService_UpdateWorkInfo_Call {
+	return &mockLegacyService_UpdateWorkInfo_Call{Call: _e.mock.On("UpdateWorkInfo", ctx, uin, info)}
+}
+
+func (_c *mockLegacyService_UpdateWorkInfo_Call) Run(run func(ctx context.Context, uin uint32, info state.ICQWorkInfo)) *mockLegacyService_UpdateWorkInfo_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 uint32
+		if args[1] != nil {
+			arg1 = args[1].(uint32)
+		}
+		var arg2 state.ICQWorkInfo
+		if args[2] != nil {
+			arg2 = args[2].(state.ICQWorkInfo)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+		)
+	})
+	return _c
+}
+
+func (_c *mockLegacyService_UpdateWorkInfo_Call) Return(err error) *mockLegacyService_UpdateWorkInfo_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *mockLegacyService_UpdateWorkInfo_Call) RunAndReturn(run func(ctx context.Context, uin uint32, info state.ICQWorkInfo) error) *mockLegacyService_UpdateWorkInfo_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // ValidateCredentials provides a mock function for the type mockLegacyService
 func (_mock *mockLegacyService) ValidateCredentials(ctx context.Context, uin uint32, password string) (bool, error) {
 	ret := _mock.Called(ctx, uin, password)
@@ -2140,63 +2455,3 @@ func (_c *mockLegacyService_WhitePagesSearch_Call) RunAndReturn(run func(ctx con
 	_c.Call.Return(run)
 	return _c
 }
-
-// UpdateBasicInfo provides a mock function for the type mockLegacyService
-func (_mock *mockLegacyService) UpdateBasicInfo(ctx context.Context, uin uint32, info state.ICQBasicInfo) error {
-	ret := _mock.Called(ctx, uin, info)
-	if len(ret) == 0 {
-		panic("no return value specified for UpdateBasicInfo")
-	}
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQBasicInfo) error); ok {
-		r0 = returnFunc(ctx, uin, info)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// UpdateWorkInfo provides a mock function for the type mockLegacyService
-func (_mock *mockLegacyService) UpdateWorkInfo(ctx context.Context, uin uint32, info state.ICQWorkInfo) error {
-	ret := _mock.Called(ctx, uin, info)
-	if len(ret) == 0 {
-		panic("no return value specified for UpdateWorkInfo")
-	}
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQWorkInfo) error); ok {
-		r0 = returnFunc(ctx, uin, info)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// UpdateMoreInfo provides a mock function for the type mockLegacyService
-func (_mock *mockLegacyService) UpdateMoreInfo(ctx context.Context, uin uint32, info state.ICQMoreInfo) error {
-	ret := _mock.Called(ctx, uin, info)
-	if len(ret) == 0 {
-		panic("no return value specified for UpdateMoreInfo")
-	}
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQMoreInfo) error); ok {
-		r0 = returnFunc(ctx, uin, info)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}
-
-// UpdatePermissions provides a mock function for the type mockLegacyService
-func (_mock *mockLegacyService) UpdatePermissions(ctx context.Context, uin uint32, info state.ICQPermissions) error {
-	ret := _mock.Called(ctx, uin, info)
-	if len(ret) == 0 {
-		panic("no return value specified for UpdatePermissions")
-	}
-	var r0 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQPermissions) error); ok {
-		r0 = returnFunc(ctx, uin, info)
-	} else {
-		r0 = ret.Error(0)
-	}
-	return r0
-}

server/icq_legacy/service_test.go

@@ -426,14 +426,16 @@ func TestICQLegacyService_ProcessContactList(t *testing.T) {
 			}
 
 			clientSideBuddyListMgr := newMockClientSideBuddyListManager(t)
-			// Expect AddBuddy for each contact in the request
-			for _, contactUIN := range tc.req.Contacts {
-				contactName := state.NewIdentScreenName(strconv.FormatUint(uint64(contactUIN), 10))
-				ownerName := state.NewIdentScreenName(strconv.FormatUint(uint64(tc.req.UIN), 10))
-				clientSideBuddyListMgr.EXPECT().
-					AddBuddy(mock.Anything, ownerName, contactName).
-					Return(nil)
-			}
+			userFinder := newMockICQUserFinder(t)
+			// ProcessContactList adds both forward and reverse buddy entries
+			clientSideBuddyListMgr.EXPECT().
+				AddBuddy(mock.Anything, mock.Anything, mock.Anything).
+				Return(nil).
+				Maybe()
+			userFinder.EXPECT().
+				FindByUIN(mock.Anything, mock.Anything).
+				Return(state.User{}, nil).
+				Maybe()
 
 			svc := NewICQLegacyService(
 				newMockUserManager(t),
@@ -442,7 +444,7 @@ func TestICQLegacyService_ProcessContactList(t *testing.T) {
 				newMockMessageRelayer(t),
 				newMockBuddyBroadcaster(t),
 				newMockOfflineMessageManager(t),
-				newMockICQUserFinder(t),
+				userFinder,
 				newMockICQUserUpdater(t),
 				newMockFeedbagManager(t),
 				newMockRelationshipFetcher(t),
@@ -485,16 +487,6 @@ func TestICQLegacyService_ProcessStatusChange(t *testing.T) {
 				OldStatus: ICQLegacyStatusOnline,
 				NewStatus: ICQLegacyStatusAway,
 			},
-			mockParams: mockParams{
-				buddyBroadcasterParams: buddyBroadcasterParams{
-					broadcastBuddyArrivedParams: broadcastBuddyArrivedParams{
-						{
-							screenName: state.NewIdentScreenName("11111"),
-							err:        nil,
-						},
-					},
-				},
-			},
 			setupLegacyMgr: func(t *testing.T, svc *ICQLegacyService) {
 				sess := newTestLegacySession(11111, legacySessionOptContactList([]uint32{22222}))
 				contactSess := newTestLegacySession(22222, legacySessionOptContactList([]uint32{11111}))
@@ -515,35 +507,18 @@ func TestICQLegacyService_ProcessStatusChange(t *testing.T) {
 				OldStatus: ICQLegacyStatusOnline,
 				NewStatus: ICQLegacyStatusAway,
 			},
-			mockParams: mockParams{
-				buddyBroadcasterParams: buddyBroadcasterParams{
-					broadcastBuddyArrivedParams: broadcastBuddyArrivedParams{
-						{
-							screenName: state.NewIdentScreenName("99999"),
-							err:        nil,
-						},
-					},
-				},
-			},
 			wantTargets: 0,
 		},
 	}
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			buddyBroadcaster := newMockBuddyBroadcaster(t)
-			for _, p := range tc.mockParams.broadcastBuddyArrivedParams {
-				buddyBroadcaster.EXPECT().
-					BroadcastBuddyArrived(matchContext(), p.screenName, mock.Anything).
-					Return(p.err)
-			}
-
 			svc := NewICQLegacyService(
 				newMockUserManager(t),
 				newMockAccountManager(t),
 				newMockSessionRetriever(t),
 				newMockMessageRelayer(t),
-				buddyBroadcaster,
+				newMockBuddyBroadcaster(t),
 				newMockOfflineMessageManager(t),
 				newMockICQUserFinder(t),
 				newMockICQUserUpdater(t),

server/oscar/mock_feedbag_service_test.go

@@ -321,6 +321,75 @@ func (_c *mockFeedbagService_QueryIfModified_Call) RunAndReturn(run func(ctx con
 	return _c
 }
 
+// RequestAuthorizeToHost provides a mock function for the type mockFeedbagService
+func (_mock *mockFeedbagService) RequestAuthorizeToHost(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.SNAC_0x13_0x18_FeedbagRequestAuthorizationToHost) error {
+	ret := _mock.Called(ctx, instance, inFrame, inBody)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RequestAuthorizeToHost")
+	}
+
+	var r0 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.SNAC_0x13_0x18_FeedbagRequestAuthorizationToHost) error); ok {
+		r0 = returnFunc(ctx, instance, inFrame, inBody)
+	} else {
+		r0 = ret.Error(0)
+	}
+	return r0
+}
+
+// mockFeedbagService_RequestAuthorizeToHost_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestAuthorizeToHost'
+type mockFeedbagService_RequestAuthorizeToHost_Call struct {
+	*mock.Call
+}
+
+// RequestAuthorizeToHost is a helper method to define mock.On call
+//   - ctx context.Context
+//   - instance *state.SessionInstance
+//   - inFrame wire.SNACFrame
+//   - inBody wire.SNAC_0x13_0x18_FeedbagRequestAuthorizationToHost
+func (_e *mockFeedbagService_Expecter) RequestAuthorizeToHost(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}) *mockFeedbagService_RequestAuthorizeToHost_Call {
+	return &mockFeedbagService_RequestAuthorizeToHost_Call{Call: _e.mock.On("RequestAuthorizeToHost", ctx, instance, inFrame, inBody)}
+}
+
+func (_c *mockFeedbagService_RequestAuthorizeToHost_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.SNAC_0x13_0x18_FeedbagRequestAuthorizationToHost)) *mockFeedbagService_RequestAuthorizeToHost_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *state.SessionInstance
+		if args[1] != nil {
+			arg1 = args[1].(*state.SessionInstance)
+		}
+		var arg2 wire.SNACFrame
+		if args[2] != nil {
+			arg2 = args[2].(wire.SNACFrame)
+		}
+		var arg3 wire.SNAC_0x13_0x18_FeedbagRequestAuthorizationToHost
+		if args[3] != nil {
+			arg3 = args[3].(wire.SNAC_0x13_0x18_FeedbagRequestAuthorizationToHost)
+		}
+		run(
+			arg0,
+			arg1,
+			arg2,
+			arg3,
+		)
+	})
+	return _c
+}
+
+func (_c *mockFeedbagService_RequestAuthorizeToHost_Call) Return(err error) *mockFeedbagService_RequestAuthorizeToHost_Call {
+	_c.Call.Return(err)
+	return _c
+}
+
+func (_c *mockFeedbagService_RequestAuthorizeToHost_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.SNAC_0x13_0x18_FeedbagRequestAuthorizationToHost) error) *mockFeedbagService_RequestAuthorizeToHost_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // RespondAuthorizeToHost provides a mock function for the type mockFeedbagService
 func (_mock *mockFeedbagService) RespondAuthorizeToHost(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.SNAC_0x13_0x1A_FeedbagRespondAuthorizeToHost) error {
 	ret := _mock.Called(ctx, instance, inFrame, inBody)