refactoring

.mockery.yaml

@@ -1,6 +1,6 @@
 with-expecter: True
 dir: "{{.InterfaceDir}}"
-mockname: "Mock{{.InterfaceName}}"
+mockname: "mock{{.InterfaceName}}"
 inpackage: True
 packages:
   github.com/mkaminski/goaim/server:

cmd/main.go

@@ -47,7 +47,7 @@ func main() {
 		feedbagHandler := handler.NewFeedbagService(sm, fm)
 		icbmHandler := handler.NewICBMService(sm, fm)
 
-		router := server.BOSServiceRouter{
+		bosService := server.BOSService{
 			AlertRouter:       server.NewAlertRouter(logger),
 			AuthHandler:       authHandler,
 			BuddyRouter:       server.NewBuddyRouter(logger, buddyHandler),
@@ -61,8 +61,7 @@ func main() {
 				Logger: logger,
 			},
 		}
-
-		server.ListenBOS(cfg, router, authHandler, logger.With("svc", "BOS"))
+		server.ListenBOS(cfg, bosService, logger.With("svc", "BOS"))
 		wg.Done()
 	}()
 	go func() {
@@ -70,8 +69,17 @@ func main() {
 		oserviceHandler := handler.NewOServiceService(cfg, sm, fm)
 		chatHandler := handler.NewChatService(cr)
 		oserviceChatHandler := handler.NewOServiceServiceForChat(*oserviceHandler, cr)
-		router := server.NewChatServiceRouter(logger, cfg, oserviceHandler, *chatHandler, oserviceChatHandler)
-		server.ListenChat(cfg, router, cr, authHandler, logger.With("svc", "CHAT"))
+
+		chatService := server.ChatService{
+			AuthHandler:        authHandler,
+			OServiceChatRouter: server.NewOServiceRouterForChat(logger, oserviceHandler, oserviceChatHandler),
+			ChatRouter:         server.NewChatRouter(logger, chatHandler),
+			Config:             cfg,
+			RouteLogger: server.RouteLogger{
+				Logger: logger,
+			},
+		}
+		server.ListenChat(cfg, chatService, logger.With("svc", "CHAT"))
 		wg.Done()
 	}()
 	go func() {

handler/auth.go

@@ -15,47 +15,44 @@ import (
 
 func NewAuthService(cfg server.Config, sm SessionManager, fm FeedbagManager, um UserManager, cr *state.ChatRegistry) *AuthService {
 	return &AuthService{
-		sm:  sm,
-		fm:  fm,
-		um:  um,
-		cfg: cfg,
-		cr:  cr,
+		sessionManager: sm,
+		feedbagManager: fm,
+		config:         cfg,
+		userManager:    um,
+		chatRegistry:   cr,
 	}
 }
 
-func newStubUser(screenName string) (state.User, error) {
-	u := state.User{ScreenName: screenName}
+type AuthService struct {
+	sessionManager SessionManager
+	feedbagManager FeedbagManager
+	userManager    UserManager
+	config         server.Config
+	chatRegistry   *state.ChatRegistry
+}
 
-	uid, err := uuid.NewRandom()
+func (s AuthService) RetrieveChatSession(ctx context.Context, chatID string, sessID string) (*state.Session, error) {
+	_, chatSessMgr, err := s.chatRegistry.Retrieve(chatID)
 	if err != nil {
-		return u, err
+		return nil, err
 	}
-	u.AuthKey = uid.String()
-
-	if err := u.HashPassword("welcome1"); err != nil {
-		return u, err
+	chatSess, found := chatSessMgr.(ChatSessionManager).Retrieve(sessID)
+	if !found {
+		return nil, fmt.Errorf("unable to find user for session. chat id: %s, sess id: %s", chatID, sessID)
 	}
-	return u, u.HashPassword("welcome1")
-}
-
-type AuthService struct {
-	sm  SessionManager
-	fm  FeedbagManager
-	um  UserManager
-	cfg server.Config
-	cr  *state.ChatRegistry
+	return chatSess, nil
 }
 
 func (s AuthService) Signout(ctx context.Context, sess *state.Session) error {
-	if err := broadcastDeparture(ctx, sess, s.sm, s.fm); err != nil {
+	if err := broadcastDeparture(ctx, sess, s.sessionManager, s.feedbagManager); err != nil {
 		return err
 	}
-	s.sm.Remove(sess)
+	s.sessionManager.Remove(sess)
 	return nil
 }
 
 func (s AuthService) SignoutChat(ctx context.Context, sess *state.Session, chatID string) {
-	chatRoom, chatSessMgr, err := s.cr.Retrieve(chatID)
+	chatRoom, chatSessMgr, err := s.chatRegistry.Retrieve(chatID)
 	if err != nil {
 		fmt.Println("error getting chat room to remove")
 		return
@@ -63,7 +60,7 @@ func (s AuthService) SignoutChat(ctx context.Context, sess *state.Session, chatI
 	alertUserLeft(ctx, sess, chatSessMgr.(ChatSessionManager))
 	chatSessMgr.(ChatSessionManager).Remove(sess)
 	if chatSessMgr.(ChatSessionManager).Empty() {
-		s.cr.RemoveRoom(chatRoom.Cookie)
+		s.chatRegistry.RemoveRoom(chatRoom.Cookie)
 	}
 }
 
@@ -81,7 +78,7 @@ func (s AuthService) VerifyLogin(conn net.Conn) (*state.Session, uint32, error)
 		return nil, 0, errors.New("unable to get session id from payload")
 	}
 
-	sess, ok := s.sm.Retrieve(string(ID))
+	sess, ok := s.sessionManager.Retrieve(string(ID))
 	if !ok {
 		return nil, 0, fmt.Errorf("unable to find session by id %s", ID)
 	}
@@ -153,14 +150,14 @@ func (s AuthService) ReceiveAndSendAuthChallenge(snacPayloadIn oscar.SNAC_0x17_0
 
 	var authKey string
 
-	u, err := s.um.GetUser(screenName)
+	u, err := s.userManager.GetUser(screenName)
 	switch {
 	case err != nil:
 		return oscar.XMessage{}, err
 	case u != nil:
 		// user lookup succeeded
 		authKey = u.AuthKey
-	case s.cfg.DisableAuth:
+	case s.config.DisableAuth:
 		// can't find user, generate stub auth key
 		authKey = newUUID().String()
 	default:
@@ -201,20 +198,20 @@ func (s AuthService) ReceiveAndSendBUCPLoginRequest(snacPayloadIn oscar.SNAC_0x1
 
 	loginOK := false
 
-	u, err := s.um.GetUser(screenName)
+	u, err := s.userManager.GetUser(screenName)
 	switch {
 	case err != nil:
 		return oscar.XMessage{}, err
 	case u != nil && bytes.Equal(u.PassHash, md5Hash):
 		// password check succeeded
 		loginOK = true
-	case s.cfg.DisableAuth:
+	case s.config.DisableAuth:
 		// login failed but let them in anyway
 		newUser, err := newStubUser(screenName)
 		if err != nil {
 			return oscar.XMessage{}, err
 		}
-		if err := s.um.UpsertUser(newUser); err != nil {
+		if err := s.userManager.UpsertUser(newUser); err != nil {
 			return oscar.XMessage{}, err
 		}
 		loginOK = true
@@ -224,9 +221,9 @@ func (s AuthService) ReceiveAndSendBUCPLoginRequest(snacPayloadIn oscar.SNAC_0x1
 	snacPayloadOut.AddTLV(oscar.NewTLV(oscar.TLVScreenName, screenName))
 
 	if loginOK {
-		sess := s.sm.NewSessionWithSN(newUUID().String(), screenName)
+		sess := s.sessionManager.NewSessionWithSN(newUUID().String(), screenName)
 		snacPayloadOut.AddTLVList([]oscar.TLV{
-			oscar.NewTLV(oscar.TLVReconnectHere, server.Address(s.cfg.OSCARHost, s.cfg.BOSPort)),
+			oscar.NewTLV(oscar.TLVReconnectHere, server.Address(s.config.OSCARHost, s.config.BOSPort)),
 			oscar.NewTLV(oscar.TLVAuthorizationCookie, sess.ID()),
 		})
 	} else {
@@ -243,3 +240,18 @@ func (s AuthService) ReceiveAndSendBUCPLoginRequest(snacPayloadIn oscar.SNAC_0x1
 		SnacOut: snacPayloadOut,
 	}, nil
 }
+
+func newStubUser(screenName string) (state.User, error) {
+	u := state.User{ScreenName: screenName}
+
+	uid, err := uuid.NewRandom()
+	if err != nil {
+		return u, err
+	}
+	u.AuthKey = uid.String()
+
+	if err := u.HashPassword("welcome1"); err != nil {
+		return u, err
+	}
+	return u, u.HashPassword("welcome1")
+}

handler/auth_test.go

@@ -130,7 +130,7 @@ func TestReceiveAndSendBUCPLoginRequest(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			sess := newTestSession(tc.userInDB.ScreenName, sessOptID(tc.sessionUUID.String()))
-			um := NewMockUserManager(t)
+			um := newMockUserManager(t)
 			um.EXPECT().
 				GetUser(tc.userInDB.ScreenName).
 				Return(&userGoodPwd, nil).
@@ -139,15 +139,15 @@ func TestReceiveAndSendBUCPLoginRequest(t *testing.T) {
 				UpsertUser(mock.Anything).
 				Return(nil).
 				Maybe()
-			sm := NewMockSessionManager(t)
+			sm := newMockSessionManager(t)
 			sm.EXPECT().
 				NewSessionWithSN(tc.sessionUUID.String(), tc.userInDB.ScreenName).
 				Return(sess).
 				Maybe()
 			svc := AuthService{
-				cfg: tc.cfg,
-				sm:  sm,
-				um:  um,
+				config:         tc.cfg,
+				sessionManager: sm,
+				userManager:    um,
 			}
 			fnNewUUID := func() uuid.UUID {
 				return tc.sessionUUID
@@ -255,14 +255,14 @@ func TestReceiveAndSendAuthChallenge(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			um := NewMockUserManager(t)
+			um := newMockUserManager(t)
 			um.EXPECT().
 				GetUser(string(tc.inputSNAC.TLVList[0].Val)).
 				Return(tc.userInDB, nil).
 				Maybe()
 			svc := AuthService{
-				cfg: tc.cfg,
-				um:  um,
+				config:      tc.cfg,
+				userManager: um,
 			}
 			fnNewUUID := func() uuid.UUID {
 				return tc.fnNewUUID

handler/chat_nav.go

@@ -19,16 +19,16 @@ func NewChatRoom() state.ChatRoom {
 
 func NewChatNavService(logger *slog.Logger, cr *state.ChatRegistry, newChatRoom func() state.ChatRoom, newChatSessMgr func() ChatSessionManager) *ChatNavService {
 	return &ChatNavService{
-		Logger:         logger,
-		cr:             cr,
-		newChatRoom:    newChatRoom,
+		logger:         logger,
+		chatRegistry:   cr,
+		newChatRoom:    NewChatRoom,
 		newChatSessMgr: newChatSessMgr,
 	}
 }
 
 type ChatNavService struct {
-	Logger         *slog.Logger
-	cr             *state.ChatRegistry
+	logger         *slog.Logger
+	chatRegistry   *state.ChatRegistry
 	newChatRoom    func() state.ChatRoom
 	newChatSessMgr func() ChatSessionManager
 }
@@ -78,7 +78,7 @@ func (s ChatNavService) CreateRoomHandler(ctx context.Context, sess *state.Sessi
 
 	chatSessMgr := s.newChatSessMgr()
 
-	s.cr.Register(room, chatSessMgr)
+	s.chatRegistry.Register(room, chatSessMgr)
 
 	// add user to chat room
 	chatSessMgr.NewSessionWithSN(sess.ID(), sess.ScreenName())
@@ -107,7 +107,7 @@ func (s ChatNavService) CreateRoomHandler(ctx context.Context, sess *state.Sessi
 }
 
 func (s ChatNavService) RequestRoomInfoHandler(_ context.Context, snacPayloadIn oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo) (oscar.XMessage, error) {
-	room, _, err := s.cr.Retrieve(string(snacPayloadIn.Cookie))
+	room, _, err := s.chatRegistry.Retrieve(string(snacPayloadIn.Cookie))
 	if err != nil {
 		return oscar.XMessage{}, err
 	}

handler/chat_nav_test.go

@@ -17,7 +17,7 @@ func TestSendAndReceiveCreateRoom(t *testing.T) {
 
 	cr := state.NewChatRegistry()
 
-	sm := NewMockChatSessionManager(t)
+	sm := newMockChatSessionManager(t)
 	sm.EXPECT().NewSessionWithSN(userSess.ID(), userSess.ScreenName()).
 		Return(&state.Session{})
 
@@ -36,7 +36,7 @@ func TestSendAndReceiveCreateRoom(t *testing.T) {
 		},
 	}
 	svc := ChatNavService{
-		cr: cr,
+		chatRegistry: cr,
 		newChatRoom: func() state.ChatRoom {
 			return state.ChatRoom{
 				Cookie:     "dummy-cookie",

handler/chat_session_manager_mock.go

@@ -11,60 +11,60 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockChatSessionManager is an autogenerated mock type for the ChatSessionManager type
-type MockChatSessionManager struct {
+// mockChatSessionManager is an autogenerated mock type for the ChatSessionManager type
+type mockChatSessionManager struct {
 	mock.Mock
 }
 
-type MockChatSessionManager_Expecter struct {
+type mockChatSessionManager_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockChatSessionManager) EXPECT() *MockChatSessionManager_Expecter {
-	return &MockChatSessionManager_Expecter{mock: &_m.Mock}
+func (_m *mockChatSessionManager) EXPECT() *mockChatSessionManager_Expecter {
+	return &mockChatSessionManager_Expecter{mock: &_m.Mock}
 }
 
 // Broadcast provides a mock function with given fields: ctx, msg
-func (_m *MockChatSessionManager) Broadcast(ctx context.Context, msg oscar.XMessage) {
+func (_m *mockChatSessionManager) Broadcast(ctx context.Context, msg oscar.XMessage) {
 	_m.Called(ctx, msg)
 }
 
-// MockChatSessionManager_Broadcast_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Broadcast'
-type MockChatSessionManager_Broadcast_Call struct {
+// mockChatSessionManager_Broadcast_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Broadcast'
+type mockChatSessionManager_Broadcast_Call struct {
 	*mock.Call
 }
 
 // Broadcast is a helper method to define mock.On call
 //   - ctx context.Context
 //   - msg oscar.XMessage
-func (_e *MockChatSessionManager_Expecter) Broadcast(ctx interface{}, msg interface{}) *MockChatSessionManager_Broadcast_Call {
-	return &MockChatSessionManager_Broadcast_Call{Call: _e.mock.On("Broadcast", ctx, msg)}
+func (_e *mockChatSessionManager_Expecter) Broadcast(ctx interface{}, msg interface{}) *mockChatSessionManager_Broadcast_Call {
+	return &mockChatSessionManager_Broadcast_Call{Call: _e.mock.On("Broadcast", ctx, msg)}
 }
 
-func (_c *MockChatSessionManager_Broadcast_Call) Run(run func(ctx context.Context, msg oscar.XMessage)) *MockChatSessionManager_Broadcast_Call {
+func (_c *mockChatSessionManager_Broadcast_Call) Run(run func(ctx context.Context, msg oscar.XMessage)) *mockChatSessionManager_Broadcast_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.XMessage))
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_Broadcast_Call) Return() *MockChatSessionManager_Broadcast_Call {
+func (_c *mockChatSessionManager_Broadcast_Call) Return() *mockChatSessionManager_Broadcast_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockChatSessionManager_Broadcast_Call) RunAndReturn(run func(context.Context, oscar.XMessage)) *MockChatSessionManager_Broadcast_Call {
+func (_c *mockChatSessionManager_Broadcast_Call) RunAndReturn(run func(context.Context, oscar.XMessage)) *mockChatSessionManager_Broadcast_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // BroadcastExcept provides a mock function with given fields: ctx, except, msg
-func (_m *MockChatSessionManager) BroadcastExcept(ctx context.Context, except *state.Session, msg oscar.XMessage) {
+func (_m *mockChatSessionManager) BroadcastExcept(ctx context.Context, except *state.Session, msg oscar.XMessage) {
 	_m.Called(ctx, except, msg)
 }
 
-// MockChatSessionManager_BroadcastExcept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastExcept'
-type MockChatSessionManager_BroadcastExcept_Call struct {
+// mockChatSessionManager_BroadcastExcept_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastExcept'
+type mockChatSessionManager_BroadcastExcept_Call struct {
 	*mock.Call
 }
 
@@ -72,34 +72,34 @@ type MockChatSessionManager_BroadcastExcept_Call struct {
 //   - ctx context.Context
 //   - except *state.Session
 //   - msg oscar.XMessage
-func (_e *MockChatSessionManager_Expecter) BroadcastExcept(ctx interface{}, except interface{}, msg interface{}) *MockChatSessionManager_BroadcastExcept_Call {
-	return &MockChatSessionManager_BroadcastExcept_Call{Call: _e.mock.On("BroadcastExcept", ctx, except, msg)}
+func (_e *mockChatSessionManager_Expecter) BroadcastExcept(ctx interface{}, except interface{}, msg interface{}) *mockChatSessionManager_BroadcastExcept_Call {
+	return &mockChatSessionManager_BroadcastExcept_Call{Call: _e.mock.On("BroadcastExcept", ctx, except, msg)}
 }
 
-func (_c *MockChatSessionManager_BroadcastExcept_Call) Run(run func(ctx context.Context, except *state.Session, msg oscar.XMessage)) *MockChatSessionManager_BroadcastExcept_Call {
+func (_c *mockChatSessionManager_BroadcastExcept_Call) Run(run func(ctx context.Context, except *state.Session, msg oscar.XMessage)) *mockChatSessionManager_BroadcastExcept_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.XMessage))
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_BroadcastExcept_Call) Return() *MockChatSessionManager_BroadcastExcept_Call {
+func (_c *mockChatSessionManager_BroadcastExcept_Call) Return() *mockChatSessionManager_BroadcastExcept_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockChatSessionManager_BroadcastExcept_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.XMessage)) *MockChatSessionManager_BroadcastExcept_Call {
+func (_c *mockChatSessionManager_BroadcastExcept_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.XMessage)) *mockChatSessionManager_BroadcastExcept_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // BroadcastToScreenNames provides a mock function with given fields: ctx, screenNames, msg
-func (_m *MockChatSessionManager) BroadcastToScreenNames(ctx context.Context, screenNames []string, msg oscar.XMessage) {
+func (_m *mockChatSessionManager) BroadcastToScreenNames(ctx context.Context, screenNames []string, msg oscar.XMessage) {
 	_m.Called(ctx, screenNames, msg)
 }
 
-// MockChatSessionManager_BroadcastToScreenNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastToScreenNames'
-type MockChatSessionManager_BroadcastToScreenNames_Call struct {
+// mockChatSessionManager_BroadcastToScreenNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastToScreenNames'
+type mockChatSessionManager_BroadcastToScreenNames_Call struct {
 	*mock.Call
 }
 
@@ -107,29 +107,29 @@ type MockChatSessionManager_BroadcastToScreenNames_Call struct {
 //   - ctx context.Context
 //   - screenNames []string
 //   - msg oscar.XMessage
-func (_e *MockChatSessionManager_Expecter) BroadcastToScreenNames(ctx interface{}, screenNames interface{}, msg interface{}) *MockChatSessionManager_BroadcastToScreenNames_Call {
-	return &MockChatSessionManager_BroadcastToScreenNames_Call{Call: _e.mock.On("BroadcastToScreenNames", ctx, screenNames, msg)}
+func (_e *mockChatSessionManager_Expecter) BroadcastToScreenNames(ctx interface{}, screenNames interface{}, msg interface{}) *mockChatSessionManager_BroadcastToScreenNames_Call {
+	return &mockChatSessionManager_BroadcastToScreenNames_Call{Call: _e.mock.On("BroadcastToScreenNames", ctx, screenNames, msg)}
 }
 
-func (_c *MockChatSessionManager_BroadcastToScreenNames_Call) Run(run func(ctx context.Context, screenNames []string, msg oscar.XMessage)) *MockChatSessionManager_BroadcastToScreenNames_Call {
+func (_c *mockChatSessionManager_BroadcastToScreenNames_Call) Run(run func(ctx context.Context, screenNames []string, msg oscar.XMessage)) *mockChatSessionManager_BroadcastToScreenNames_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].([]string), args[2].(oscar.XMessage))
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_BroadcastToScreenNames_Call) Return() *MockChatSessionManager_BroadcastToScreenNames_Call {
+func (_c *mockChatSessionManager_BroadcastToScreenNames_Call) Return() *mockChatSessionManager_BroadcastToScreenNames_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockChatSessionManager_BroadcastToScreenNames_Call) RunAndReturn(run func(context.Context, []string, oscar.XMessage)) *MockChatSessionManager_BroadcastToScreenNames_Call {
+func (_c *mockChatSessionManager_BroadcastToScreenNames_Call) RunAndReturn(run func(context.Context, []string, oscar.XMessage)) *mockChatSessionManager_BroadcastToScreenNames_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Empty provides a mock function with given fields:
-func (_m *MockChatSessionManager) Empty() bool {
+func (_m *mockChatSessionManager) Empty() bool {
 	ret := _m.Called()
 
 	var r0 bool
@@ -142,35 +142,35 @@ func (_m *MockChatSessionManager) Empty() bool {
 	return r0
 }
 
-// MockChatSessionManager_Empty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Empty'
-type MockChatSessionManager_Empty_Call struct {
+// mockChatSessionManager_Empty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Empty'
+type mockChatSessionManager_Empty_Call struct {
 	*mock.Call
 }
 
 // Empty is a helper method to define mock.On call
-func (_e *MockChatSessionManager_Expecter) Empty() *MockChatSessionManager_Empty_Call {
-	return &MockChatSessionManager_Empty_Call{Call: _e.mock.On("Empty")}
+func (_e *mockChatSessionManager_Expecter) Empty() *mockChatSessionManager_Empty_Call {
+	return &mockChatSessionManager_Empty_Call{Call: _e.mock.On("Empty")}
 }
 
-func (_c *MockChatSessionManager_Empty_Call) Run(run func()) *MockChatSessionManager_Empty_Call {
+func (_c *mockChatSessionManager_Empty_Call) Run(run func()) *mockChatSessionManager_Empty_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run()
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_Empty_Call) Return(_a0 bool) *MockChatSessionManager_Empty_Call {
+func (_c *mockChatSessionManager_Empty_Call) Return(_a0 bool) *mockChatSessionManager_Empty_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockChatSessionManager_Empty_Call) RunAndReturn(run func() bool) *MockChatSessionManager_Empty_Call {
+func (_c *mockChatSessionManager_Empty_Call) RunAndReturn(run func() bool) *mockChatSessionManager_Empty_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // NewSessionWithSN provides a mock function with given fields: sessID, screenName
-func (_m *MockChatSessionManager) NewSessionWithSN(sessID string, screenName string) *state.Session {
+func (_m *mockChatSessionManager) NewSessionWithSN(sessID string, screenName string) *state.Session {
 	ret := _m.Called(sessID, screenName)
 
 	var r0 *state.Session
@@ -185,37 +185,37 @@ func (_m *MockChatSessionManager) NewSessionWithSN(sessID string, screenName str
 	return r0
 }
 
-// MockChatSessionManager_NewSessionWithSN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSessionWithSN'
-type MockChatSessionManager_NewSessionWithSN_Call struct {
+// mockChatSessionManager_NewSessionWithSN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSessionWithSN'
+type mockChatSessionManager_NewSessionWithSN_Call struct {
 	*mock.Call
 }
 
 // NewSessionWithSN is a helper method to define mock.On call
 //   - sessID string
 //   - screenName string
-func (_e *MockChatSessionManager_Expecter) NewSessionWithSN(sessID interface{}, screenName interface{}) *MockChatSessionManager_NewSessionWithSN_Call {
-	return &MockChatSessionManager_NewSessionWithSN_Call{Call: _e.mock.On("NewSessionWithSN", sessID, screenName)}
+func (_e *mockChatSessionManager_Expecter) NewSessionWithSN(sessID interface{}, screenName interface{}) *mockChatSessionManager_NewSessionWithSN_Call {
+	return &mockChatSessionManager_NewSessionWithSN_Call{Call: _e.mock.On("NewSessionWithSN", sessID, screenName)}
 }
 
-func (_c *MockChatSessionManager_NewSessionWithSN_Call) Run(run func(sessID string, screenName string)) *MockChatSessionManager_NewSessionWithSN_Call {
+func (_c *mockChatSessionManager_NewSessionWithSN_Call) Run(run func(sessID string, screenName string)) *mockChatSessionManager_NewSessionWithSN_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string), args[1].(string))
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_NewSessionWithSN_Call) Return(_a0 *state.Session) *MockChatSessionManager_NewSessionWithSN_Call {
+func (_c *mockChatSessionManager_NewSessionWithSN_Call) Return(_a0 *state.Session) *mockChatSessionManager_NewSessionWithSN_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockChatSessionManager_NewSessionWithSN_Call) RunAndReturn(run func(string, string) *state.Session) *MockChatSessionManager_NewSessionWithSN_Call {
+func (_c *mockChatSessionManager_NewSessionWithSN_Call) RunAndReturn(run func(string, string) *state.Session) *mockChatSessionManager_NewSessionWithSN_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Participants provides a mock function with given fields:
-func (_m *MockChatSessionManager) Participants() []*state.Session {
+func (_m *mockChatSessionManager) Participants() []*state.Session {
 	ret := _m.Called()
 
 	var r0 []*state.Session
@@ -230,68 +230,68 @@ func (_m *MockChatSessionManager) Participants() []*state.Session {
 	return r0
 }
 
-// MockChatSessionManager_Participants_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Participants'
-type MockChatSessionManager_Participants_Call struct {
+// mockChatSessionManager_Participants_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Participants'
+type mockChatSessionManager_Participants_Call struct {
 	*mock.Call
 }
 
 // Participants is a helper method to define mock.On call
-func (_e *MockChatSessionManager_Expecter) Participants() *MockChatSessionManager_Participants_Call {
-	return &MockChatSessionManager_Participants_Call{Call: _e.mock.On("Participants")}
+func (_e *mockChatSessionManager_Expecter) Participants() *mockChatSessionManager_Participants_Call {
+	return &mockChatSessionManager_Participants_Call{Call: _e.mock.On("Participants")}
 }
 
-func (_c *MockChatSessionManager_Participants_Call) Run(run func()) *MockChatSessionManager_Participants_Call {
+func (_c *mockChatSessionManager_Participants_Call) Run(run func()) *mockChatSessionManager_Participants_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run()
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_Participants_Call) Return(_a0 []*state.Session) *MockChatSessionManager_Participants_Call {
+func (_c *mockChatSessionManager_Participants_Call) Return(_a0 []*state.Session) *mockChatSessionManager_Participants_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockChatSessionManager_Participants_Call) RunAndReturn(run func() []*state.Session) *MockChatSessionManager_Participants_Call {
+func (_c *mockChatSessionManager_Participants_Call) RunAndReturn(run func() []*state.Session) *mockChatSessionManager_Participants_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Remove provides a mock function with given fields: sess
-func (_m *MockChatSessionManager) Remove(sess *state.Session) {
+func (_m *mockChatSessionManager) Remove(sess *state.Session) {
 	_m.Called(sess)
 }
 
-// MockChatSessionManager_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
-type MockChatSessionManager_Remove_Call struct {
+// mockChatSessionManager_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
+type mockChatSessionManager_Remove_Call struct {
 	*mock.Call
 }
 
 // Remove is a helper method to define mock.On call
 //   - sess *state.Session
-func (_e *MockChatSessionManager_Expecter) Remove(sess interface{}) *MockChatSessionManager_Remove_Call {
-	return &MockChatSessionManager_Remove_Call{Call: _e.mock.On("Remove", sess)}
+func (_e *mockChatSessionManager_Expecter) Remove(sess interface{}) *mockChatSessionManager_Remove_Call {
+	return &mockChatSessionManager_Remove_Call{Call: _e.mock.On("Remove", sess)}
 }
 
-func (_c *MockChatSessionManager_Remove_Call) Run(run func(sess *state.Session)) *MockChatSessionManager_Remove_Call {
+func (_c *mockChatSessionManager_Remove_Call) Run(run func(sess *state.Session)) *mockChatSessionManager_Remove_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(*state.Session))
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_Remove_Call) Return() *MockChatSessionManager_Remove_Call {
+func (_c *mockChatSessionManager_Remove_Call) Return() *mockChatSessionManager_Remove_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockChatSessionManager_Remove_Call) RunAndReturn(run func(*state.Session)) *MockChatSessionManager_Remove_Call {
+func (_c *mockChatSessionManager_Remove_Call) RunAndReturn(run func(*state.Session)) *mockChatSessionManager_Remove_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Retrieve provides a mock function with given fields: ID
-func (_m *MockChatSessionManager) Retrieve(ID string) (*state.Session, bool) {
+func (_m *mockChatSessionManager) Retrieve(ID string) (*state.Session, bool) {
 	ret := _m.Called(ID)
 
 	var r0 *state.Session
@@ -316,36 +316,36 @@ func (_m *MockChatSessionManager) Retrieve(ID string) (*state.Session, bool) {
 	return r0, r1
 }
 
-// MockChatSessionManager_Retrieve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Retrieve'
-type MockChatSessionManager_Retrieve_Call struct {
+// mockChatSessionManager_Retrieve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Retrieve'
+type mockChatSessionManager_Retrieve_Call struct {
 	*mock.Call
 }
 
 // Retrieve is a helper method to define mock.On call
 //   - ID string
-func (_e *MockChatSessionManager_Expecter) Retrieve(ID interface{}) *MockChatSessionManager_Retrieve_Call {
-	return &MockChatSessionManager_Retrieve_Call{Call: _e.mock.On("Retrieve", ID)}
+func (_e *mockChatSessionManager_Expecter) Retrieve(ID interface{}) *mockChatSessionManager_Retrieve_Call {
+	return &mockChatSessionManager_Retrieve_Call{Call: _e.mock.On("Retrieve", ID)}
 }
 
-func (_c *MockChatSessionManager_Retrieve_Call) Run(run func(ID string)) *MockChatSessionManager_Retrieve_Call {
+func (_c *mockChatSessionManager_Retrieve_Call) Run(run func(ID string)) *mockChatSessionManager_Retrieve_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_Retrieve_Call) Return(_a0 *state.Session, _a1 bool) *MockChatSessionManager_Retrieve_Call {
+func (_c *mockChatSessionManager_Retrieve_Call) Return(_a0 *state.Session, _a1 bool) *mockChatSessionManager_Retrieve_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockChatSessionManager_Retrieve_Call) RunAndReturn(run func(string) (*state.Session, bool)) *MockChatSessionManager_Retrieve_Call {
+func (_c *mockChatSessionManager_Retrieve_Call) RunAndReturn(run func(string) (*state.Session, bool)) *mockChatSessionManager_Retrieve_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RetrieveByScreenName provides a mock function with given fields: screenName
-func (_m *MockChatSessionManager) RetrieveByScreenName(screenName string) *state.Session {
+func (_m *mockChatSessionManager) RetrieveByScreenName(screenName string) *state.Session {
 	ret := _m.Called(screenName)
 
 	var r0 *state.Session
@@ -360,41 +360,41 @@ func (_m *MockChatSessionManager) RetrieveByScreenName(screenName string) *state
 	return r0
 }
 
-// MockChatSessionManager_RetrieveByScreenName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByScreenName'
-type MockChatSessionManager_RetrieveByScreenName_Call struct {
+// mockChatSessionManager_RetrieveByScreenName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByScreenName'
+type mockChatSessionManager_RetrieveByScreenName_Call struct {
 	*mock.Call
 }
 
 // RetrieveByScreenName is a helper method to define mock.On call
 //   - screenName string
-func (_e *MockChatSessionManager_Expecter) RetrieveByScreenName(screenName interface{}) *MockChatSessionManager_RetrieveByScreenName_Call {
-	return &MockChatSessionManager_RetrieveByScreenName_Call{Call: _e.mock.On("RetrieveByScreenName", screenName)}
+func (_e *mockChatSessionManager_Expecter) RetrieveByScreenName(screenName interface{}) *mockChatSessionManager_RetrieveByScreenName_Call {
+	return &mockChatSessionManager_RetrieveByScreenName_Call{Call: _e.mock.On("RetrieveByScreenName", screenName)}
 }
 
-func (_c *MockChatSessionManager_RetrieveByScreenName_Call) Run(run func(screenName string)) *MockChatSessionManager_RetrieveByScreenName_Call {
+func (_c *mockChatSessionManager_RetrieveByScreenName_Call) Run(run func(screenName string)) *mockChatSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_RetrieveByScreenName_Call) Return(_a0 *state.Session) *MockChatSessionManager_RetrieveByScreenName_Call {
+func (_c *mockChatSessionManager_RetrieveByScreenName_Call) Return(_a0 *state.Session) *mockChatSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockChatSessionManager_RetrieveByScreenName_Call) RunAndReturn(run func(string) *state.Session) *MockChatSessionManager_RetrieveByScreenName_Call {
+func (_c *mockChatSessionManager_RetrieveByScreenName_Call) RunAndReturn(run func(string) *state.Session) *mockChatSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // SendToScreenName provides a mock function with given fields: ctx, screenName, msg
-func (_m *MockChatSessionManager) SendToScreenName(ctx context.Context, screenName string, msg oscar.XMessage) {
+func (_m *mockChatSessionManager) SendToScreenName(ctx context.Context, screenName string, msg oscar.XMessage) {
 	_m.Called(ctx, screenName, msg)
 }
 
-// MockChatSessionManager_SendToScreenName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendToScreenName'
-type MockChatSessionManager_SendToScreenName_Call struct {
+// mockChatSessionManager_SendToScreenName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendToScreenName'
+type mockChatSessionManager_SendToScreenName_Call struct {
 	*mock.Call
 }
 
@@ -402,34 +402,34 @@ type MockChatSessionManager_SendToScreenName_Call struct {
 //   - ctx context.Context
 //   - screenName string
 //   - msg oscar.XMessage
-func (_e *MockChatSessionManager_Expecter) SendToScreenName(ctx interface{}, screenName interface{}, msg interface{}) *MockChatSessionManager_SendToScreenName_Call {
-	return &MockChatSessionManager_SendToScreenName_Call{Call: _e.mock.On("SendToScreenName", ctx, screenName, msg)}
+func (_e *mockChatSessionManager_Expecter) SendToScreenName(ctx interface{}, screenName interface{}, msg interface{}) *mockChatSessionManager_SendToScreenName_Call {
+	return &mockChatSessionManager_SendToScreenName_Call{Call: _e.mock.On("SendToScreenName", ctx, screenName, msg)}
 }
 
-func (_c *MockChatSessionManager_SendToScreenName_Call) Run(run func(ctx context.Context, screenName string, msg oscar.XMessage)) *MockChatSessionManager_SendToScreenName_Call {
+func (_c *mockChatSessionManager_SendToScreenName_Call) Run(run func(ctx context.Context, screenName string, msg oscar.XMessage)) *mockChatSessionManager_SendToScreenName_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(string), args[2].(oscar.XMessage))
 	})
 	return _c
 }
 
-func (_c *MockChatSessionManager_SendToScreenName_Call) Return() *MockChatSessionManager_SendToScreenName_Call {
+func (_c *mockChatSessionManager_SendToScreenName_Call) Return() *mockChatSessionManager_SendToScreenName_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockChatSessionManager_SendToScreenName_Call) RunAndReturn(run func(context.Context, string, oscar.XMessage)) *MockChatSessionManager_SendToScreenName_Call {
+func (_c *mockChatSessionManager_SendToScreenName_Call) RunAndReturn(run func(context.Context, string, oscar.XMessage)) *mockChatSessionManager_SendToScreenName_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockChatSessionManager creates a new instance of MockChatSessionManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockChatSessionManager creates a new instance of mockChatSessionManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockChatSessionManager(t interface {
+func newMockChatSessionManager(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockChatSessionManager {
-	mock := &MockChatSessionManager{}
+}) *mockChatSessionManager {
+	mock := &mockChatSessionManager{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

handler/chat_test.go

@@ -117,7 +117,7 @@ func TestSendAndReceiveChatChannelMsgToHost(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			chatID := "the-chat-id"
 
-			chatSessMgr := NewMockChatSessionManager(t)
+			chatSessMgr := newMockChatSessionManager(t)
 			chatSessMgr.EXPECT().
 				BroadcastExcept(mock.Anything, tc.userSession, tc.expectSNACToParticipants)
 

handler/feedbag.go

@@ -8,12 +8,12 @@ import (
 )
 
 func NewFeedbagService(sm SessionManager, fm FeedbagManager) *FeedbagService {
-	return &FeedbagService{sm: sm, fm: fm}
+	return &FeedbagService{sessionManager: sm, feedbagManager: fm}
 }
 
 type FeedbagService struct {
-	sm SessionManager
-	fm FeedbagManager
+	sessionManager SessionManager
+	feedbagManager FeedbagManager
 }
 
 func (s FeedbagService) RightsQueryHandler(context.Context) oscar.XMessage {
@@ -65,7 +65,7 @@ func (s FeedbagService) RightsQueryHandler(context.Context) oscar.XMessage {
 }
 
 func (s FeedbagService) QueryHandler(_ context.Context, sess *state.Session) (oscar.XMessage, error) {
-	fb, err := s.fm.Retrieve(sess.ScreenName())
+	fb, err := s.feedbagManager.Retrieve(sess.ScreenName())
 	if err != nil {
 		return oscar.XMessage{}, err
 	}
@@ -73,7 +73,7 @@ func (s FeedbagService) QueryHandler(_ context.Context, sess *state.Session) (os
 	lm := time.UnixMilli(0)
 
 	if len(fb) > 0 {
-		lm, err = s.fm.LastModified(sess.ScreenName())
+		lm, err = s.feedbagManager.LastModified(sess.ScreenName())
 		if err != nil {
 			return oscar.XMessage{}, err
 		}
@@ -93,7 +93,7 @@ func (s FeedbagService) QueryHandler(_ context.Context, sess *state.Session) (os
 }
 
 func (s FeedbagService) QueryIfModifiedHandler(_ context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error) {
-	fb, err := s.fm.Retrieve(sess.ScreenName())
+	fb, err := s.feedbagManager.Retrieve(sess.ScreenName())
 	if err != nil {
 		return oscar.XMessage{}, err
 	}
@@ -101,7 +101,7 @@ func (s FeedbagService) QueryIfModifiedHandler(_ context.Context, sess *state.Se
 	lm := time.UnixMilli(0)
 
 	if len(fb) > 0 {
-		lm, err = s.fm.LastModified(sess.ScreenName())
+		lm, err = s.feedbagManager.LastModified(sess.ScreenName())
 		if err != nil {
 			return oscar.XMessage{}, err
 		}
@@ -149,19 +149,19 @@ func (s FeedbagService) InsertItemHandler(ctx context.Context, sess *state.Sessi
 		}
 	}
 
-	if err := s.fm.Upsert(sess.ScreenName(), snacPayloadIn.Items); err != nil {
+	if err := s.feedbagManager.Upsert(sess.ScreenName(), snacPayloadIn.Items); err != nil {
 		return oscar.XMessage{}, nil
 	}
 
 	for _, item := range snacPayloadIn.Items {
 		switch item.ClassID {
 		case oscar.FeedbagClassIdBuddy, oscar.FeedbagClassIDPermit: // add new buddy
-			unicastArrival(ctx, item.Name, sess.ScreenName(), s.sm)
+			unicastArrival(ctx, item.Name, sess.ScreenName(), s.sessionManager)
 		case oscar.FeedbagClassIDDeny: // block buddy
 			// notify this user that buddy is offline
-			unicastDeparture(ctx, item.Name, sess.ScreenName(), s.sm)
+			unicastDeparture(ctx, item.Name, sess.ScreenName(), s.sessionManager)
 			// notify former buddy that this user is offline
-			unicastDeparture(ctx, sess.ScreenName(), item.Name, s.sm)
+			unicastDeparture(ctx, sess.ScreenName(), item.Name, s.sessionManager)
 		}
 	}
 
@@ -180,14 +180,14 @@ func (s FeedbagService) InsertItemHandler(ctx context.Context, sess *state.Sessi
 }
 
 func (s FeedbagService) UpdateItemHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error) {
-	if err := s.fm.Upsert(sess.ScreenName(), snacPayloadIn.Items); err != nil {
+	if err := s.feedbagManager.Upsert(sess.ScreenName(), snacPayloadIn.Items); err != nil {
 		return oscar.XMessage{}, nil
 	}
 
 	for _, item := range snacPayloadIn.Items {
 		switch item.ClassID {
 		case oscar.FeedbagClassIdBuddy, oscar.FeedbagClassIDPermit:
-			unicastArrival(ctx, item.Name, sess.ScreenName(), s.sm)
+			unicastArrival(ctx, item.Name, sess.ScreenName(), s.sessionManager)
 		}
 	}
 
@@ -206,14 +206,14 @@ func (s FeedbagService) UpdateItemHandler(ctx context.Context, sess *state.Sessi
 }
 
 func (s FeedbagService) DeleteItemHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error) {
-	if err := s.fm.Delete(sess.ScreenName(), snacPayloadIn.Items); err != nil {
+	if err := s.feedbagManager.Delete(sess.ScreenName(), snacPayloadIn.Items); err != nil {
 		return oscar.XMessage{}, err
 	}
 
 	for _, item := range snacPayloadIn.Items {
 		if item.ClassID == oscar.FeedbagClassIDDeny {
-			unicastArrival(ctx, item.Name, sess.ScreenName(), s.sm)
-			unicastArrival(ctx, sess.ScreenName(), item.Name, s.sm)
+			unicastArrival(ctx, item.Name, sess.ScreenName(), s.sessionManager)
+			unicastArrival(ctx, sess.ScreenName(), item.Name, s.sessionManager)
 		}
 	}
 

handler/feedbag_manager_mock.go

@@ -11,21 +11,21 @@ import (
 	time "time"
 )
 
-// MockFeedbagManager is an autogenerated mock type for the FeedbagManager type
-type MockFeedbagManager struct {
+// mockFeedbagManager is an autogenerated mock type for the FeedbagManager type
+type mockFeedbagManager struct {
 	mock.Mock
 }
 
-type MockFeedbagManager_Expecter struct {
+type mockFeedbagManager_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockFeedbagManager) EXPECT() *MockFeedbagManager_Expecter {
-	return &MockFeedbagManager_Expecter{mock: &_m.Mock}
+func (_m *mockFeedbagManager) EXPECT() *mockFeedbagManager_Expecter {
+	return &mockFeedbagManager_Expecter{mock: &_m.Mock}
 }
 
 // Blocked provides a mock function with given fields: sn1, sn2
-func (_m *MockFeedbagManager) Blocked(sn1 string, sn2 string) (state.BlockedState, error) {
+func (_m *mockFeedbagManager) Blocked(sn1 string, sn2 string) (state.BlockedState, error) {
 	ret := _m.Called(sn1, sn2)
 
 	var r0 state.BlockedState
@@ -48,37 +48,37 @@ func (_m *MockFeedbagManager) Blocked(sn1 string, sn2 string) (state.BlockedStat
 	return r0, r1
 }
 
-// MockFeedbagManager_Blocked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Blocked'
-type MockFeedbagManager_Blocked_Call struct {
+// mockFeedbagManager_Blocked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Blocked'
+type mockFeedbagManager_Blocked_Call struct {
 	*mock.Call
 }
 
 // Blocked is a helper method to define mock.On call
 //   - sn1 string
 //   - sn2 string
-func (_e *MockFeedbagManager_Expecter) Blocked(sn1 interface{}, sn2 interface{}) *MockFeedbagManager_Blocked_Call {
-	return &MockFeedbagManager_Blocked_Call{Call: _e.mock.On("Blocked", sn1, sn2)}
+func (_e *mockFeedbagManager_Expecter) Blocked(sn1 interface{}, sn2 interface{}) *mockFeedbagManager_Blocked_Call {
+	return &mockFeedbagManager_Blocked_Call{Call: _e.mock.On("Blocked", sn1, sn2)}
 }
 
-func (_c *MockFeedbagManager_Blocked_Call) Run(run func(sn1 string, sn2 string)) *MockFeedbagManager_Blocked_Call {
+func (_c *mockFeedbagManager_Blocked_Call) Run(run func(sn1 string, sn2 string)) *mockFeedbagManager_Blocked_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string), args[1].(string))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagManager_Blocked_Call) Return(_a0 state.BlockedState, _a1 error) *MockFeedbagManager_Blocked_Call {
+func (_c *mockFeedbagManager_Blocked_Call) Return(_a0 state.BlockedState, _a1 error) *mockFeedbagManager_Blocked_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagManager_Blocked_Call) RunAndReturn(run func(string, string) (state.BlockedState, error)) *MockFeedbagManager_Blocked_Call {
+func (_c *mockFeedbagManager_Blocked_Call) RunAndReturn(run func(string, string) (state.BlockedState, error)) *mockFeedbagManager_Blocked_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Buddies provides a mock function with given fields: screenName
-func (_m *MockFeedbagManager) Buddies(screenName string) ([]string, error) {
+func (_m *mockFeedbagManager) Buddies(screenName string) ([]string, error) {
 	ret := _m.Called(screenName)
 
 	var r0 []string
@@ -103,36 +103,36 @@ func (_m *MockFeedbagManager) Buddies(screenName string) ([]string, error) {
 	return r0, r1
 }
 
-// MockFeedbagManager_Buddies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Buddies'
-type MockFeedbagManager_Buddies_Call struct {
+// mockFeedbagManager_Buddies_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Buddies'
+type mockFeedbagManager_Buddies_Call struct {
 	*mock.Call
 }
 
 // Buddies is a helper method to define mock.On call
 //   - screenName string
-func (_e *MockFeedbagManager_Expecter) Buddies(screenName interface{}) *MockFeedbagManager_Buddies_Call {
-	return &MockFeedbagManager_Buddies_Call{Call: _e.mock.On("Buddies", screenName)}
+func (_e *mockFeedbagManager_Expecter) Buddies(screenName interface{}) *mockFeedbagManager_Buddies_Call {
+	return &mockFeedbagManager_Buddies_Call{Call: _e.mock.On("Buddies", screenName)}
 }
 
-func (_c *MockFeedbagManager_Buddies_Call) Run(run func(screenName string)) *MockFeedbagManager_Buddies_Call {
+func (_c *mockFeedbagManager_Buddies_Call) Run(run func(screenName string)) *mockFeedbagManager_Buddies_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagManager_Buddies_Call) Return(_a0 []string, _a1 error) *MockFeedbagManager_Buddies_Call {
+func (_c *mockFeedbagManager_Buddies_Call) Return(_a0 []string, _a1 error) *mockFeedbagManager_Buddies_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagManager_Buddies_Call) RunAndReturn(run func(string) ([]string, error)) *MockFeedbagManager_Buddies_Call {
+func (_c *mockFeedbagManager_Buddies_Call) RunAndReturn(run func(string) ([]string, error)) *mockFeedbagManager_Buddies_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Delete provides a mock function with given fields: screenName, items
-func (_m *MockFeedbagManager) Delete(screenName string, items []oscar.FeedbagItem) error {
+func (_m *mockFeedbagManager) Delete(screenName string, items []oscar.FeedbagItem) error {
 	ret := _m.Called(screenName, items)
 
 	var r0 error
@@ -145,37 +145,37 @@ func (_m *MockFeedbagManager) Delete(screenName string, items []oscar.FeedbagIte
 	return r0
 }
 
-// MockFeedbagManager_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
-type MockFeedbagManager_Delete_Call struct {
+// mockFeedbagManager_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
+type mockFeedbagManager_Delete_Call struct {
 	*mock.Call
 }
 
 // Delete is a helper method to define mock.On call
 //   - screenName string
 //   - items []oscar.FeedbagItem
-func (_e *MockFeedbagManager_Expecter) Delete(screenName interface{}, items interface{}) *MockFeedbagManager_Delete_Call {
-	return &MockFeedbagManager_Delete_Call{Call: _e.mock.On("Delete", screenName, items)}
+func (_e *mockFeedbagManager_Expecter) Delete(screenName interface{}, items interface{}) *mockFeedbagManager_Delete_Call {
+	return &mockFeedbagManager_Delete_Call{Call: _e.mock.On("Delete", screenName, items)}
 }
 
-func (_c *MockFeedbagManager_Delete_Call) Run(run func(screenName string, items []oscar.FeedbagItem)) *MockFeedbagManager_Delete_Call {
+func (_c *mockFeedbagManager_Delete_Call) Run(run func(screenName string, items []oscar.FeedbagItem)) *mockFeedbagManager_Delete_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string), args[1].([]oscar.FeedbagItem))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagManager_Delete_Call) Return(_a0 error) *MockFeedbagManager_Delete_Call {
+func (_c *mockFeedbagManager_Delete_Call) Return(_a0 error) *mockFeedbagManager_Delete_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockFeedbagManager_Delete_Call) RunAndReturn(run func(string, []oscar.FeedbagItem) error) *MockFeedbagManager_Delete_Call {
+func (_c *mockFeedbagManager_Delete_Call) RunAndReturn(run func(string, []oscar.FeedbagItem) error) *mockFeedbagManager_Delete_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // InterestedUsers provides a mock function with given fields: screenName
-func (_m *MockFeedbagManager) InterestedUsers(screenName string) ([]string, error) {
+func (_m *mockFeedbagManager) InterestedUsers(screenName string) ([]string, error) {
 	ret := _m.Called(screenName)
 
 	var r0 []string
@@ -200,36 +200,36 @@ func (_m *MockFeedbagManager) InterestedUsers(screenName string) ([]string, erro
 	return r0, r1
 }
 
-// MockFeedbagManager_InterestedUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InterestedUsers'
-type MockFeedbagManager_InterestedUsers_Call struct {
+// mockFeedbagManager_InterestedUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InterestedUsers'
+type mockFeedbagManager_InterestedUsers_Call struct {
 	*mock.Call
 }
 
 // InterestedUsers is a helper method to define mock.On call
 //   - screenName string
-func (_e *MockFeedbagManager_Expecter) InterestedUsers(screenName interface{}) *MockFeedbagManager_InterestedUsers_Call {
-	return &MockFeedbagManager_InterestedUsers_Call{Call: _e.mock.On("InterestedUsers", screenName)}
+func (_e *mockFeedbagManager_Expecter) InterestedUsers(screenName interface{}) *mockFeedbagManager_InterestedUsers_Call {
+	return &mockFeedbagManager_InterestedUsers_Call{Call: _e.mock.On("InterestedUsers", screenName)}
 }
 
-func (_c *MockFeedbagManager_InterestedUsers_Call) Run(run func(screenName string)) *MockFeedbagManager_InterestedUsers_Call {
+func (_c *mockFeedbagManager_InterestedUsers_Call) Run(run func(screenName string)) *mockFeedbagManager_InterestedUsers_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagManager_InterestedUsers_Call) Return(_a0 []string, _a1 error) *MockFeedbagManager_InterestedUsers_Call {
+func (_c *mockFeedbagManager_InterestedUsers_Call) Return(_a0 []string, _a1 error) *mockFeedbagManager_InterestedUsers_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagManager_InterestedUsers_Call) RunAndReturn(run func(string) ([]string, error)) *MockFeedbagManager_InterestedUsers_Call {
+func (_c *mockFeedbagManager_InterestedUsers_Call) RunAndReturn(run func(string) ([]string, error)) *mockFeedbagManager_InterestedUsers_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // LastModified provides a mock function with given fields: screenName
-func (_m *MockFeedbagManager) LastModified(screenName string) (time.Time, error) {
+func (_m *mockFeedbagManager) LastModified(screenName string) (time.Time, error) {
 	ret := _m.Called(screenName)
 
 	var r0 time.Time
@@ -252,36 +252,36 @@ func (_m *MockFeedbagManager) LastModified(screenName string) (time.Time, error)
 	return r0, r1
 }
 
-// MockFeedbagManager_LastModified_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastModified'
-type MockFeedbagManager_LastModified_Call struct {
+// mockFeedbagManager_LastModified_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastModified'
+type mockFeedbagManager_LastModified_Call struct {
 	*mock.Call
 }
 
 // LastModified is a helper method to define mock.On call
 //   - screenName string
-func (_e *MockFeedbagManager_Expecter) LastModified(screenName interface{}) *MockFeedbagManager_LastModified_Call {
-	return &MockFeedbagManager_LastModified_Call{Call: _e.mock.On("LastModified", screenName)}
+func (_e *mockFeedbagManager_Expecter) LastModified(screenName interface{}) *mockFeedbagManager_LastModified_Call {
+	return &mockFeedbagManager_LastModified_Call{Call: _e.mock.On("LastModified", screenName)}
 }
 
-func (_c *MockFeedbagManager_LastModified_Call) Run(run func(screenName string)) *MockFeedbagManager_LastModified_Call {
+func (_c *mockFeedbagManager_LastModified_Call) Run(run func(screenName string)) *mockFeedbagManager_LastModified_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagManager_LastModified_Call) Return(_a0 time.Time, _a1 error) *MockFeedbagManager_LastModified_Call {
+func (_c *mockFeedbagManager_LastModified_Call) Return(_a0 time.Time, _a1 error) *mockFeedbagManager_LastModified_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagManager_LastModified_Call) RunAndReturn(run func(string) (time.Time, error)) *MockFeedbagManager_LastModified_Call {
+func (_c *mockFeedbagManager_LastModified_Call) RunAndReturn(run func(string) (time.Time, error)) *mockFeedbagManager_LastModified_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Retrieve provides a mock function with given fields: screenName
-func (_m *MockFeedbagManager) Retrieve(screenName string) ([]oscar.FeedbagItem, error) {
+func (_m *mockFeedbagManager) Retrieve(screenName string) ([]oscar.FeedbagItem, error) {
 	ret := _m.Called(screenName)
 
 	var r0 []oscar.FeedbagItem
@@ -306,36 +306,36 @@ func (_m *MockFeedbagManager) Retrieve(screenName string) ([]oscar.FeedbagItem,
 	return r0, r1
 }
 
-// MockFeedbagManager_Retrieve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Retrieve'
-type MockFeedbagManager_Retrieve_Call struct {
+// mockFeedbagManager_Retrieve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Retrieve'
+type mockFeedbagManager_Retrieve_Call struct {
 	*mock.Call
 }
 
 // Retrieve is a helper method to define mock.On call
 //   - screenName string
-func (_e *MockFeedbagManager_Expecter) Retrieve(screenName interface{}) *MockFeedbagManager_Retrieve_Call {
-	return &MockFeedbagManager_Retrieve_Call{Call: _e.mock.On("Retrieve", screenName)}
+func (_e *mockFeedbagManager_Expecter) Retrieve(screenName interface{}) *mockFeedbagManager_Retrieve_Call {
+	return &mockFeedbagManager_Retrieve_Call{Call: _e.mock.On("Retrieve", screenName)}
 }
 
-func (_c *MockFeedbagManager_Retrieve_Call) Run(run func(screenName string)) *MockFeedbagManager_Retrieve_Call {
+func (_c *mockFeedbagManager_Retrieve_Call) Run(run func(screenName string)) *mockFeedbagManager_Retrieve_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagManager_Retrieve_Call) Return(_a0 []oscar.FeedbagItem, _a1 error) *MockFeedbagManager_Retrieve_Call {
+func (_c *mockFeedbagManager_Retrieve_Call) Return(_a0 []oscar.FeedbagItem, _a1 error) *mockFeedbagManager_Retrieve_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagManager_Retrieve_Call) RunAndReturn(run func(string) ([]oscar.FeedbagItem, error)) *MockFeedbagManager_Retrieve_Call {
+func (_c *mockFeedbagManager_Retrieve_Call) RunAndReturn(run func(string) ([]oscar.FeedbagItem, error)) *mockFeedbagManager_Retrieve_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Upsert provides a mock function with given fields: screenName, items
-func (_m *MockFeedbagManager) Upsert(screenName string, items []oscar.FeedbagItem) error {
+func (_m *mockFeedbagManager) Upsert(screenName string, items []oscar.FeedbagItem) error {
 	ret := _m.Called(screenName, items)
 
 	var r0 error
@@ -348,42 +348,42 @@ func (_m *MockFeedbagManager) Upsert(screenName string, items []oscar.FeedbagIte
 	return r0
 }
 
-// MockFeedbagManager_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'
-type MockFeedbagManager_Upsert_Call struct {
+// mockFeedbagManager_Upsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upsert'
+type mockFeedbagManager_Upsert_Call struct {
 	*mock.Call
 }
 
 // Upsert is a helper method to define mock.On call
 //   - screenName string
 //   - items []oscar.FeedbagItem
-func (_e *MockFeedbagManager_Expecter) Upsert(screenName interface{}, items interface{}) *MockFeedbagManager_Upsert_Call {
-	return &MockFeedbagManager_Upsert_Call{Call: _e.mock.On("Upsert", screenName, items)}
+func (_e *mockFeedbagManager_Expecter) Upsert(screenName interface{}, items interface{}) *mockFeedbagManager_Upsert_Call {
+	return &mockFeedbagManager_Upsert_Call{Call: _e.mock.On("Upsert", screenName, items)}
 }
 
-func (_c *MockFeedbagManager_Upsert_Call) Run(run func(screenName string, items []oscar.FeedbagItem)) *MockFeedbagManager_Upsert_Call {
+func (_c *mockFeedbagManager_Upsert_Call) Run(run func(screenName string, items []oscar.FeedbagItem)) *mockFeedbagManager_Upsert_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string), args[1].([]oscar.FeedbagItem))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagManager_Upsert_Call) Return(_a0 error) *MockFeedbagManager_Upsert_Call {
+func (_c *mockFeedbagManager_Upsert_Call) Return(_a0 error) *mockFeedbagManager_Upsert_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockFeedbagManager_Upsert_Call) RunAndReturn(run func(string, []oscar.FeedbagItem) error) *MockFeedbagManager_Upsert_Call {
+func (_c *mockFeedbagManager_Upsert_Call) RunAndReturn(run func(string, []oscar.FeedbagItem) error) *mockFeedbagManager_Upsert_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockFeedbagManager creates a new instance of MockFeedbagManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockFeedbagManager creates a new instance of mockFeedbagManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockFeedbagManager(t interface {
+func newMockFeedbagManager(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockFeedbagManager {
-	mock := &MockFeedbagManager{}
+}) *mockFeedbagManager {
+	mock := &mockFeedbagManager{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

handler/feedbag_test.go

@@ -76,7 +76,7 @@ func TestQueryHandler(t *testing.T) {
 			//
 			// initialize dependencies
 			//
-			fm := NewMockFeedbagManager(t)
+			fm := newMockFeedbagManager(t)
 			fm.EXPECT().
 				Retrieve(tc.screenName).
 				Return(tc.feedbagItems, nil).
@@ -90,7 +90,7 @@ func TestQueryHandler(t *testing.T) {
 			//
 			senderSession := newTestSession(tc.screenName)
 			svc := FeedbagService{
-				fm: fm,
+				feedbagManager: fm,
 			}
 			outputSNAC, err := svc.QueryHandler(nil, senderSession)
 			assert.NoError(t, err)
@@ -200,7 +200,7 @@ func TestQueryIfModifiedHandler(t *testing.T) {
 			//
 			// initialize dependencies
 			//
-			fm := NewMockFeedbagManager(t)
+			fm := newMockFeedbagManager(t)
 			fm.EXPECT().
 				Retrieve(tc.screenName).
 				Return(tc.feedbagItems, nil).
@@ -214,7 +214,7 @@ func TestQueryIfModifiedHandler(t *testing.T) {
 			//
 			senderSession := newTestSession(tc.screenName)
 			svc := FeedbagService{
-				fm: fm,
+				feedbagManager: fm,
 			}
 			outputSNAC, err := svc.QueryIfModifiedHandler(nil, senderSession, tc.inputSNAC)
 			assert.NoError(t, err)
@@ -533,7 +533,7 @@ func TestInsertItemHandler(t *testing.T) {
 			//
 			// initialize dependencies
 			//
-			fm := NewMockFeedbagManager(t)
+			fm := newMockFeedbagManager(t)
 			fm.EXPECT().
 				Upsert(tc.userSession.ScreenName(), tc.inputSNAC.Items).
 				Return(nil).
@@ -542,7 +542,7 @@ func TestInsertItemHandler(t *testing.T) {
 				Buddies(tc.userSession.ScreenName()).
 				Return([]string{}, nil).
 				Maybe()
-			sm := NewMockSessionManager(t)
+			sm := newMockSessionManager(t)
 			for screenName, val := range tc.screenNameLookups {
 				sm.EXPECT().
 					RetrieveByScreenName(screenName).
@@ -558,8 +558,8 @@ func TestInsertItemHandler(t *testing.T) {
 			// send input SNAC
 			//
 			svc := FeedbagService{
-				fm: fm,
-				sm: sm,
+				feedbagManager: fm,
+				sessionManager: sm,
 			}
 			output, err := svc.InsertItemHandler(nil, tc.userSession, tc.inputSNAC)
 			assert.NoError(t, err)

handler/icbm.go

@@ -12,12 +12,12 @@ const (
 )
 
 func NewICBMService(sm SessionManager, fm FeedbagManager) *ICBMService {
-	return &ICBMService{sm: sm, fm: fm}
+	return &ICBMService{sessionManager: sm, feedbagManager: fm}
 }
 
 type ICBMService struct {
-	sm SessionManager
-	fm FeedbagManager
+	sessionManager SessionManager
+	feedbagManager FeedbagManager
 }
 
 func (s ICBMService) ParameterQueryHandler(context.Context) oscar.XMessage {
@@ -38,7 +38,7 @@ func (s ICBMService) ParameterQueryHandler(context.Context) oscar.XMessage {
 }
 
 func (s ICBMService) ChannelMsgToHostHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error) {
-	blocked, err := s.fm.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
+	blocked, err := s.feedbagManager.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
 	if err != nil {
 		return nil, err
 	}
@@ -59,7 +59,7 @@ func (s ICBMService) ChannelMsgToHostHandler(ctx context.Context, sess *state.Se
 		}, nil
 	}
 
-	recipSess := s.sm.RetrieveByScreenName(snacPayloadIn.ScreenName)
+	recipSess := s.sessionManager.RetrieveByScreenName(snacPayloadIn.ScreenName)
 	if recipSess == nil {
 		return &oscar.XMessage{
 			SnacFrame: oscar.SnacFrame{
@@ -93,7 +93,7 @@ func (s ICBMService) ChannelMsgToHostHandler(ctx context.Context, sess *state.Se
 	// far as I can tell.
 	clientIM.AddTLVList(snacPayloadIn.TLVRestBlock.TLVList)
 
-	s.sm.SendToScreenName(ctx, recipSess.ScreenName(), oscar.XMessage{
+	s.sessionManager.SendToScreenName(ctx, recipSess.ScreenName(), oscar.XMessage{
 		SnacFrame: oscar.SnacFrame{
 			FoodGroup: oscar.ICBM,
 			SubGroup:  oscar.ICBMChannelMsgToclient,
@@ -121,7 +121,7 @@ func (s ICBMService) ChannelMsgToHostHandler(ctx context.Context, sess *state.Se
 }
 
 func (s ICBMService) ClientEventHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error {
-	blocked, err := s.fm.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
+	blocked, err := s.feedbagManager.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
 
 	switch {
 	case err != nil:
@@ -129,7 +129,7 @@ func (s ICBMService) ClientEventHandler(ctx context.Context, sess *state.Session
 	case blocked != state.BlockedNo:
 		return nil
 	default:
-		s.sm.SendToScreenName(ctx, snacPayloadIn.ScreenName, oscar.XMessage{
+		s.sessionManager.SendToScreenName(ctx, snacPayloadIn.ScreenName, oscar.XMessage{
 			SnacFrame: oscar.SnacFrame{
 				FoodGroup: oscar.ICBM,
 				SubGroup:  oscar.ICBMClientEvent,
@@ -160,7 +160,7 @@ func (s ICBMService) EvilRequestHandler(ctx context.Context, sess *state.Session
 		}, nil
 	}
 
-	blocked, err := s.fm.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
+	blocked, err := s.feedbagManager.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
 	if err != nil {
 		return oscar.XMessage{}, nil
 	}
@@ -176,7 +176,7 @@ func (s ICBMService) EvilRequestHandler(ctx context.Context, sess *state.Session
 		}, nil
 	}
 
-	recipSess := s.sm.RetrieveByScreenName(snacPayloadIn.ScreenName)
+	recipSess := s.sessionManager.RetrieveByScreenName(snacPayloadIn.ScreenName)
 	if recipSess == nil {
 		return oscar.XMessage{}, nil
 	}
@@ -202,7 +202,7 @@ func (s ICBMService) EvilRequestHandler(ctx context.Context, sess *state.Session
 		}
 	}
 
-	s.sm.SendToScreenName(ctx, recipSess.ScreenName(), oscar.XMessage{
+	s.sessionManager.SendToScreenName(ctx, recipSess.ScreenName(), oscar.XMessage{
 		SnacFrame: oscar.SnacFrame{
 			FoodGroup: oscar.OSERVICE,
 			SubGroup:  oscar.OServiceEvilNotification,
@@ -210,7 +210,7 @@ func (s ICBMService) EvilRequestHandler(ctx context.Context, sess *state.Session
 		SnacOut: notif,
 	})
 
-	if err := broadcastArrival(ctx, recipSess, s.sm, s.fm); err != nil {
+	if err := broadcastArrival(ctx, recipSess, s.sessionManager, s.feedbagManager); err != nil {
 		return oscar.XMessage{}, nil
 	}
 

handler/icbm_test.go

@@ -196,12 +196,12 @@ func TestSendAndReceiveChannelMsgTohost(t *testing.T) {
 			//
 			// initialize dependencies
 			//
-			fm := NewMockFeedbagManager(t)
+			fm := newMockFeedbagManager(t)
 			fm.EXPECT().
 				Blocked(tc.senderSession.ScreenName(), tc.inputSNAC.ScreenName).
 				Return(tc.blockedState, nil).
 				Maybe()
-			sm := NewMockSessionManager(t)
+			sm := newMockSessionManager(t)
 			sm.EXPECT().
 				RetrieveByScreenName(tc.inputSNAC.ScreenName).
 				Return(tc.recipientSession).
@@ -215,8 +215,8 @@ func TestSendAndReceiveChannelMsgTohost(t *testing.T) {
 			// send input SNAC
 			//
 			svc := ICBMService{
-				sm: sm,
-				fm: fm,
+				sessionManager: sm,
+				feedbagManager: fm,
 			}
 			outputSNAC, err := svc.ChannelMsgToHostHandler(nil, tc.senderSession, tc.inputSNAC)
 			assert.NoError(t, err)
@@ -280,12 +280,12 @@ func TestSendAndReceiveClientEvent(t *testing.T) {
 			//
 			// initialize dependencies
 			//
-			fm := NewMockFeedbagManager(t)
+			fm := newMockFeedbagManager(t)
 			fm.EXPECT().
 				Blocked(tc.senderScreenName, tc.inputSNAC.ScreenName).
 				Return(tc.blockedState, nil).
 				Maybe()
-			sm := NewMockSessionManager(t)
+			sm := newMockSessionManager(t)
 			if tc.blockedState == state.BlockedNo {
 				sm.EXPECT().
 					SendToScreenName(mock.Anything, tc.inputSNAC.ScreenName, tc.expectSNACToClient)
@@ -295,8 +295,8 @@ func TestSendAndReceiveClientEvent(t *testing.T) {
 			//
 			senderSession := newTestSession(tc.senderScreenName)
 			svc := ICBMService{
-				sm: sm,
-				fm: fm,
+				sessionManager: sm,
+				feedbagManager: fm,
 			}
 			assert.NoError(t, svc.ClientEventHandler(nil, senderSession, tc.inputSNAC))
 		})
@@ -487,7 +487,7 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 			//
 			// initialize dependencies
 			//
-			fm := NewMockFeedbagManager(t)
+			fm := newMockFeedbagManager(t)
 			fm.EXPECT().
 				Blocked(tc.senderSession.ScreenName(), tc.recipientScreenName).
 				Return(tc.blockedState, nil).
@@ -497,7 +497,7 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 				Return(tc.recipientBuddies, nil).
 				Maybe()
 			recipSess := newTestSession(tc.recipientScreenName, sessOptCannedSignonTime)
-			sm := NewMockSessionManager(t)
+			sm := newMockSessionManager(t)
 			sm.EXPECT().
 				RetrieveByScreenName(tc.recipientScreenName).
 				Return(recipSess).
@@ -513,8 +513,8 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 			//
 			senderSession := newTestSession(tc.senderSession.ScreenName())
 			svc := ICBMService{
-				sm: sm,
-				fm: fm,
+				sessionManager: sm,
+				feedbagManager: fm,
 			}
 			outputSNAC, err := svc.EvilRequestHandler(nil, senderSession, tc.inputSNAC)
 			assert.NoError(t, err)

handler/locate.go

@@ -8,16 +8,16 @@ import (
 
 func NewLocateService(sm SessionManager, fm FeedbagManager, pm ProfileManager) LocateService {
 	return LocateService{
-		sm: sm,
-		fm: fm,
-		pm: pm,
+		sessionManager: sm,
+		feedbagManager: fm,
+		profileManager: pm,
 	}
 }
 
 type LocateService struct {
-	sm SessionManager
-	fm FeedbagManager
-	pm ProfileManager
+	sessionManager SessionManager
+	feedbagManager FeedbagManager
+	profileManager ProfileManager
 }
 
 func (s LocateService) RightsQueryHandler(context.Context) oscar.XMessage {
@@ -43,7 +43,7 @@ func (s LocateService) RightsQueryHandler(context.Context) oscar.XMessage {
 func (s LocateService) SetInfoHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo) error {
 	// update profile
 	if profile, hasProfile := snacPayloadIn.GetString(oscar.LocateTLVTagsInfoSigData); hasProfile {
-		if err := s.pm.UpsertProfile(sess.ScreenName(), profile); err != nil {
+		if err := s.profileManager.UpsertProfile(sess.ScreenName(), profile); err != nil {
 			return err
 		}
 	}
@@ -51,7 +51,7 @@ func (s LocateService) SetInfoHandler(ctx context.Context, sess *state.Session,
 	// broadcast away message change to buddies
 	if awayMsg, hasAwayMsg := snacPayloadIn.GetString(oscar.LocateTLVTagsInfoUnavailableData); hasAwayMsg {
 		sess.SetAwayMessage(awayMsg)
-		if err := broadcastArrival(ctx, sess, s.sm, s.fm); err != nil {
+		if err := broadcastArrival(ctx, sess, s.sessionManager, s.feedbagManager); err != nil {
 			return err
 		}
 	}
@@ -59,7 +59,7 @@ func (s LocateService) SetInfoHandler(ctx context.Context, sess *state.Session,
 }
 
 func (s LocateService) UserInfoQuery2Handler(_ context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error) {
-	blocked, err := s.fm.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
+	blocked, err := s.feedbagManager.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
 	switch {
 	case err != nil:
 		return oscar.XMessage{}, err
@@ -75,7 +75,7 @@ func (s LocateService) UserInfoQuery2Handler(_ context.Context, sess *state.Sess
 		}, nil
 	}
 
-	buddySess := s.sm.RetrieveByScreenName(snacPayloadIn.ScreenName)
+	buddySess := s.sessionManager.RetrieveByScreenName(snacPayloadIn.ScreenName)
 	if buddySess == nil {
 		return oscar.XMessage{
 			SnacFrame: oscar.SnacFrame{
@@ -91,7 +91,7 @@ func (s LocateService) UserInfoQuery2Handler(_ context.Context, sess *state.Sess
 	var list oscar.TLVList
 
 	if snacPayloadIn.RequestProfile() {
-		profile, err := s.pm.RetrieveProfile(snacPayloadIn.ScreenName)
+		profile, err := s.profileManager.RetrieveProfile(snacPayloadIn.ScreenName)
 		if err != nil {
 			return oscar.XMessage{}, err
 		}

handler/locate_test.go

@@ -238,19 +238,19 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			fm := NewMockFeedbagManager(t)
+			fm := newMockFeedbagManager(t)
 			fm.EXPECT().
 				Blocked(tc.userSession.ScreenName(), tc.inputSNAC.ScreenName).
 				Return(tc.blockedState, nil).
 				Maybe()
-			sm := NewMockSessionManager(t)
+			sm := newMockSessionManager(t)
 			for screenName, val := range tc.screenNameLookups {
 				sm.EXPECT().
 					RetrieveByScreenName(screenName).
 					Return(val.sess).
 					Maybe()
 			}
-			pm := NewMockProfileManager(t)
+			pm := newMockProfileManager(t)
 			for screenName, val := range tc.profileLookups {
 				pm.EXPECT().
 					RetrieveProfile(screenName).
@@ -259,9 +259,9 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 			}
 
 			svc := LocateService{
-				sm: sm,
-				fm: fm,
-				pm: pm,
+				sessionManager: sm,
+				feedbagManager: fm,
+				profileManager: pm,
 			}
 			outputSNAC, err := svc.UserInfoQuery2Handler(context.Background(), tc.userSession, tc.inputSNAC)
 			assert.NoError(t, err)

handler/oservice.go

@@ -11,17 +11,17 @@ import (
 	"time"
 )
 
-func NewOServiceService(cfg server.Config, sm SessionManager, fm FeedbagManager) *OServiceService {
-	return &OServiceService{cfg: cfg, sm: sm, fm: fm}
+func NewOServiceService(cfg server.Config, sm SessionManager, fm FeedbagManager) *oServiceService {
+	return &oServiceService{cfg: cfg, sm: sm, fm: fm}
 }
 
-type OServiceService struct {
+type oServiceService struct {
 	cfg server.Config
 	fm  FeedbagManager
 	sm  SessionManager
 }
 
-func (s OServiceService) ClientVersionsHandler(_ context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage {
+func (s oServiceService) ClientVersionsHandler(_ context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage {
 	return oscar.XMessage{
 		SnacFrame: oscar.SnacFrame{
 			FoodGroup: oscar.OSERVICE,
@@ -33,7 +33,7 @@ func (s OServiceService) ClientVersionsHandler(_ context.Context, snacPayloadIn
 	}
 }
 
-func (s OServiceService) RateParamsQueryHandler(_ context.Context) oscar.XMessage {
+func (s oServiceService) RateParamsQueryHandler(_ context.Context) oscar.XMessage {
 	snacFrameOut := oscar.SnacFrame{
 		FoodGroup: oscar.OSERVICE,
 		SubGroup:  oscar.OServiceRateParamsReply,
@@ -100,7 +100,7 @@ func (s OServiceService) RateParamsQueryHandler(_ context.Context) oscar.XMessag
 	}
 }
 
-func (s OServiceService) UserInfoQueryHandler(_ context.Context, sess *state.Session) oscar.XMessage {
+func (s oServiceService) UserInfoQueryHandler(_ context.Context, sess *state.Session) oscar.XMessage {
 	return oscar.XMessage{
 		SnacFrame: oscar.SnacFrame{
 			FoodGroup: oscar.OSERVICE,
@@ -112,7 +112,7 @@ func (s OServiceService) UserInfoQueryHandler(_ context.Context, sess *state.Ses
 	}
 }
 
-func (s OServiceService) SetUserInfoFieldsHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
+func (s oServiceService) SetUserInfoFieldsHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
 	if status, hasStatus := snacPayloadIn.GetUint32(0x06); hasStatus {
 		switch status {
 		case 0x000:
@@ -140,7 +140,7 @@ func (s OServiceService) SetUserInfoFieldsHandler(ctx context.Context, sess *sta
 	}, nil
 }
 
-func (s OServiceService) IdleNotificationHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
+func (s oServiceService) IdleNotificationHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
 	if snacPayloadIn.IdleTime == 0 {
 		sess.SetActive()
 	} else {
@@ -151,15 +151,18 @@ func (s OServiceService) IdleNotificationHandler(ctx context.Context, sess *stat
 
 // RateParamsSubAddHandler exists to capture the SNAC input in unit tests to
 // verify it's correctly unmarshalled.
-func (s OServiceService) RateParamsSubAddHandler(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd) {
+func (s oServiceService) RateParamsSubAddHandler(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd) {
 }
 
-func NewOServiceServiceForBOS(oserviceService OServiceService, cr *state.ChatRegistry) *OServiceServiceForBOS {
-	return &OServiceServiceForBOS{OServiceService: oserviceService, cr: cr}
+func NewOServiceServiceForBOS(oserviceService oServiceService, cr *state.ChatRegistry) *OServiceServiceForBOS {
+	return &OServiceServiceForBOS{
+		oServiceService: oserviceService,
+		cr:              cr,
+	}
 }
 
 type OServiceServiceForBOS struct {
-	OServiceService
+	oServiceService
 	cr *state.ChatRegistry
 }
 
@@ -240,15 +243,15 @@ func (s OServiceServiceForBOS) ClientOnlineHandler(ctx context.Context, _ oscar.
 	return nil
 }
 
-func NewOServiceServiceForChat(oserviceService OServiceService, chatRegistry *state.ChatRegistry) *OServiceServiceForChat {
+func NewOServiceServiceForChat(oserviceService oServiceService, chatRegistry *state.ChatRegistry) *OServiceServiceForChat {
 	return &OServiceServiceForChat{
-		OServiceService: oserviceService,
+		oServiceService: oserviceService,
 		chatRegistry:    chatRegistry,
 	}
 }
 
 type OServiceServiceForChat struct {
-	OServiceService
+	oServiceService
 	chatRegistry *state.ChatRegistry
 }
 

handler/oservice_test.go

@@ -1,12 +1,10 @@
 package handler
 
 import (
-	"bytes"
 	"github.com/mkaminski/goaim/oscar"
 	"github.com/mkaminski/goaim/server"
 	"github.com/mkaminski/goaim/state"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
 	"testing"
 	"time"
 )
@@ -15,7 +13,7 @@ func TestReceiveAndSendServiceRequest(t *testing.T) {
 	cases := []struct {
 		// name is the unit test name
 		name string
-		// cfg is the application config
+		// config is the application config
 		cfg server.Config
 		// chatRoom is the chat room the user connects to
 		chatRoom *state.ChatRoom
@@ -115,7 +113,7 @@ func TestReceiveAndSendServiceRequest(t *testing.T) {
 			//
 			// initialize dependencies
 			//
-			sm := NewMockChatSessionManager(t)
+			sm := newMockChatSessionManager(t)
 			cr := state.NewChatRegistry()
 			if tc.chatRoom != nil {
 				sm.EXPECT().
@@ -128,7 +126,7 @@ func TestReceiveAndSendServiceRequest(t *testing.T) {
 			// send input SNAC
 			//
 			svc := OServiceServiceForBOS{
-				OServiceService: OServiceService{
+				oServiceService: oServiceService{
 					cfg: tc.cfg,
 					sm:  sm,
 				},
@@ -147,591 +145,3 @@ func TestReceiveAndSendServiceRequest(t *testing.T) {
 		})
 	}
 }
-
-func TestOServiceRouter_RouteOService_ForBOS(t *testing.T) {
-	cases := []struct {
-		// name is the unit test name
-		name string
-		// input is the request payload
-		input oscar.XMessage
-		// output is the response payload
-		output oscar.XMessage
-		// handlerErr is the mocked handler error response
-		handlerErr error
-		// expectErr is the expected error returned by the router
-		expectErr error
-	}{
-		{
-			name: "receive OServiceClientOnline, return no response",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceClientOnline,
-				},
-				SnacOut: oscar.SNAC_0x01_0x02_OServiceClientOnline{
-					GroupVersions: []struct {
-						FoodGroup   uint16
-						Version     uint16
-						ToolID      uint16
-						ToolVersion uint16
-					}{
-						{
-							FoodGroup: 10,
-						},
-					},
-				},
-			},
-			output: oscar.XMessage{},
-		},
-		{
-			name: "receive OServiceServiceRequest, return OServiceServiceResponse",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceServiceRequest,
-				},
-				SnacOut: oscar.SNAC_0x01_0x04_OServiceServiceRequest{
-					FoodGroup: 10,
-				},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceServiceResponse,
-				},
-				SnacOut: oscar.SNAC_0x01_0x05_OServiceServiceResponse{
-					TLVRestBlock: oscar.TLVRestBlock{
-						TLVList: oscar.TLVList{
-							oscar.NewTLV(0x01, uint16(1000)),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServiceRateParamsQuery, return OServiceRateParamsReply",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceRateParamsQuery,
-				},
-				SnacOut: struct{}{},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceRateParamsReply,
-				},
-				SnacOut: oscar.SNAC_0x01_0x07_OServiceRateParamsReply{
-					RateGroups: []struct {
-						ID    uint16
-						Pairs []struct {
-							FoodGroup uint16
-							SubGroup  uint16
-						} `count_prefix:"uint16"`
-					}{
-						{
-							ID: 1,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServiceRateParamsSubAdd, return no response",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceRateParamsSubAdd,
-				},
-				SnacOut: oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd{
-					TLVRestBlock: oscar.TLVRestBlock{
-						TLVList: oscar.TLVList{
-							oscar.NewTLV(0x01, []byte{1, 2, 3, 4}),
-						},
-					},
-				},
-			},
-			output: oscar.XMessage{},
-		},
-		{
-			name: "receive OServiceUserInfoQuery, return OServiceUserInfoUpdate",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceUserInfoQuery,
-				},
-				SnacOut: struct{}{},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceUserInfoUpdate,
-				},
-				SnacOut: oscar.SNAC_0x01_0x0F_OServiceUserInfoUpdate{
-					TLVUserInfo: oscar.TLVUserInfo{
-						ScreenName: "screen-name",
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServiceIdleNotification, return no response",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceIdleNotification,
-				},
-				SnacOut: oscar.SNAC_0x01_0x11_OServiceIdleNotification{
-					IdleTime: 10,
-				},
-			},
-			output: oscar.XMessage{},
-		},
-		{
-			name: "receive OServiceClientVersions, return OServiceHostVersions",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceClientVersions,
-				},
-				SnacOut: oscar.SNAC_0x01_0x17_OServiceClientVersions{
-					Versions: []uint16{
-						10,
-					},
-				},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceHostVersions,
-				},
-				SnacOut: oscar.SNAC_0x01_0x18_OServiceHostVersions{
-					Versions: []uint16{
-						10,
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServiceSetUserInfoFields, return OServiceUserInfoUpdate",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceSetUserInfoFields,
-				},
-				SnacOut: oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields{
-					TLVRestBlock: oscar.TLVRestBlock{
-						TLVList: oscar.TLVList{
-							oscar.NewTLV(0x01, []byte{1, 2, 3, 4}),
-						},
-					},
-				},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceUserInfoUpdate,
-				},
-				SnacOut: oscar.SNAC_0x01_0x0F_OServiceUserInfoUpdate{
-					TLVUserInfo: oscar.TLVUserInfo{
-						ScreenName: "screen-name",
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServicePauseReq, expect ErrUnsupportedSubGroup",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServicePauseReq,
-				},
-				SnacOut: struct{}{}, // empty SNAC
-			},
-			output:    oscar.XMessage{}, // empty SNAC
-			expectErr: server.ErrUnsupportedSubGroup,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			svc := server.NewMockOServiceHandler(t)
-			svc.EXPECT().
-				RateParamsQueryHandler(mock.Anything).
-				Return(tc.output).
-				Maybe()
-			svc.EXPECT().
-				UserInfoQueryHandler(mock.Anything, mock.Anything).
-				Return(tc.output).
-				Maybe()
-			svc.EXPECT().
-				ClientVersionsHandler(mock.Anything, tc.input.SnacOut).
-				Return(tc.output).
-				Maybe()
-			svc.EXPECT().
-				SetUserInfoFieldsHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
-				Return(tc.output, tc.handlerErr).
-				Maybe()
-			svc.EXPECT().
-				RateParamsSubAddHandler(mock.Anything, tc.input.SnacOut).
-				Maybe()
-			svc.EXPECT().
-				IdleNotificationHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
-				Return(tc.handlerErr).
-				Maybe()
-
-			svcBOS := server.NewMockOServiceBOSHandler(t)
-			svcBOS.EXPECT().
-				ServiceRequestHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
-				Return(tc.output, tc.handlerErr).
-				Maybe()
-			svcBOS.EXPECT().
-				ClientOnlineHandler(mock.Anything, tc.input.SnacOut, mock.Anything).
-				Return(tc.handlerErr).
-				Maybe()
-
-			router := server.OServiceBOSRouter{
-				OServiceRouter: server.OServiceRouter{
-					OServiceHandler: svc,
-					RouteLogger: server.RouteLogger{
-						Logger: server.NewLogger(server.Config{}),
-					},
-				},
-				OServiceBOSHandler: svcBOS,
-			}
-
-			bufIn := &bytes.Buffer{}
-			assert.NoError(t, oscar.Marshal(tc.input.SnacOut, bufIn))
-
-			bufOut := &bytes.Buffer{}
-			seq := uint32(1)
-
-			err := router.RouteOService(nil, nil, tc.input.SnacFrame, bufIn, bufOut, &seq)
-			assert.ErrorIs(t, err, tc.expectErr)
-			if tc.expectErr != nil {
-				return
-			}
-
-			if tc.output == (oscar.XMessage{}) {
-				// make sure no response was sent
-				assert.Empty(t, bufOut.Bytes())
-				return
-			}
-
-			// verify the FLAP frame
-			flap := oscar.FlapFrame{}
-			assert.NoError(t, oscar.Unmarshal(&flap, bufOut))
-
-			// make sure the sequence number was incremented
-			assert.Equal(t, uint32(2), seq)
-
-			flapBuf, err := flap.SNACBuffer(bufOut)
-			assert.NoError(t, err)
-
-			// verify the SNAC frame
-			snacFrame := oscar.SnacFrame{}
-			assert.NoError(t, oscar.Unmarshal(&snacFrame, flapBuf))
-			assert.Equal(t, tc.output.SnacFrame, snacFrame)
-
-			// verify the SNAC message
-			snacBuf := &bytes.Buffer{}
-			assert.NoError(t, oscar.Marshal(tc.output.SnacOut, snacBuf))
-			assert.Equal(t, snacBuf.Bytes(), flapBuf.Bytes())
-		})
-	}
-}
-
-func TestOServiceRouter_RouteOService_ForChat(t *testing.T) {
-	cases := []struct {
-		// name is the unit test name
-		name string
-		// input is the request payload
-		input oscar.XMessage
-		// output is the response payload
-		output oscar.XMessage
-		// handlerErr is the mocked handler error response
-		handlerErr error
-		// expectErr is the expected error returned by the router
-		expectErr error
-	}{
-		{
-			name: "receive OServiceClientOnline, return no response",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceClientOnline,
-				},
-				SnacOut: oscar.SNAC_0x01_0x02_OServiceClientOnline{
-					GroupVersions: []struct {
-						FoodGroup   uint16
-						Version     uint16
-						ToolID      uint16
-						ToolVersion uint16
-					}{
-						{
-							FoodGroup: 10,
-						},
-					},
-				},
-			},
-			output: oscar.XMessage{},
-		},
-		{
-			name: "receive OServiceServiceRequest, return OServiceServiceResponse",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceServiceRequest,
-				},
-				SnacOut: oscar.SNAC_0x01_0x04_OServiceServiceRequest{
-					FoodGroup: 10,
-				},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceServiceResponse,
-				},
-				SnacOut: oscar.SNAC_0x01_0x05_OServiceServiceResponse{
-					TLVRestBlock: oscar.TLVRestBlock{
-						TLVList: oscar.TLVList{
-							oscar.NewTLV(0x01, uint16(1000)),
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServiceRateParamsQuery, return OServiceRateParamsReply",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceRateParamsQuery,
-				},
-				SnacOut: struct{}{},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceRateParamsReply,
-				},
-				SnacOut: oscar.SNAC_0x01_0x07_OServiceRateParamsReply{
-					RateGroups: []struct {
-						ID    uint16
-						Pairs []struct {
-							FoodGroup uint16
-							SubGroup  uint16
-						} `count_prefix:"uint16"`
-					}{
-						{
-							ID: 1,
-						},
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServiceRateParamsSubAdd, return no response",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceRateParamsSubAdd,
-				},
-				SnacOut: oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd{
-					TLVRestBlock: oscar.TLVRestBlock{
-						TLVList: oscar.TLVList{
-							oscar.NewTLV(0x01, []byte{1, 2, 3, 4}),
-						},
-					},
-				},
-			},
-			output: oscar.XMessage{},
-		},
-		{
-			name: "receive OServiceUserInfoQuery, return OServiceUserInfoUpdate",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceUserInfoQuery,
-				},
-				SnacOut: struct{}{},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceUserInfoUpdate,
-				},
-				SnacOut: oscar.SNAC_0x01_0x0F_OServiceUserInfoUpdate{
-					TLVUserInfo: oscar.TLVUserInfo{
-						ScreenName: "screen-name",
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServiceIdleNotification, return no response",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceIdleNotification,
-				},
-				SnacOut: oscar.SNAC_0x01_0x11_OServiceIdleNotification{
-					IdleTime: 10,
-				},
-			},
-			output: oscar.XMessage{},
-		},
-		{
-			name: "receive OServiceClientVersions, return OServiceHostVersions",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceClientVersions,
-				},
-				SnacOut: oscar.SNAC_0x01_0x17_OServiceClientVersions{
-					Versions: []uint16{
-						10,
-					},
-				},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceHostVersions,
-				},
-				SnacOut: oscar.SNAC_0x01_0x18_OServiceHostVersions{
-					Versions: []uint16{
-						10,
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServiceSetUserInfoFields, return OServiceUserInfoUpdate",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceSetUserInfoFields,
-				},
-				SnacOut: oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields{
-					TLVRestBlock: oscar.TLVRestBlock{
-						TLVList: oscar.TLVList{
-							oscar.NewTLV(0x01, []byte{1, 2, 3, 4}),
-						},
-					},
-				},
-			},
-			output: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServiceUserInfoUpdate,
-				},
-				SnacOut: oscar.SNAC_0x01_0x0F_OServiceUserInfoUpdate{
-					TLVUserInfo: oscar.TLVUserInfo{
-						ScreenName: "screen-name",
-					},
-				},
-			},
-		},
-		{
-			name: "receive OServicePauseReq, expect ErrUnsupportedSubGroup",
-			input: oscar.XMessage{
-				SnacFrame: oscar.SnacFrame{
-					FoodGroup: oscar.OSERVICE,
-					SubGroup:  oscar.OServicePauseReq,
-				},
-				SnacOut: struct{}{}, // empty SNAC
-			},
-			output:    oscar.XMessage{}, // empty SNAC
-			expectErr: server.ErrUnsupportedSubGroup,
-		},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			svc := server.NewMockOServiceHandler(t)
-			svc.EXPECT().
-				RateParamsQueryHandler(mock.Anything).
-				Return(tc.output).
-				Maybe()
-			svc.EXPECT().
-				UserInfoQueryHandler(mock.Anything, mock.Anything).
-				Return(tc.output).
-				Maybe()
-			svc.EXPECT().
-				ClientVersionsHandler(mock.Anything, tc.input.SnacOut).
-				Return(tc.output).
-				Maybe()
-			svc.EXPECT().
-				SetUserInfoFieldsHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
-				Return(tc.output, tc.handlerErr).
-				Maybe()
-			svc.EXPECT().
-				RateParamsSubAddHandler(mock.Anything, tc.input.SnacOut).
-				Maybe()
-			svc.EXPECT().
-				IdleNotificationHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
-				Return(tc.handlerErr).
-				Maybe()
-
-			svcBOS := server.NewMockOServiceChatHandler(t)
-			svcBOS.EXPECT().
-				ServiceRequestHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
-				Return(tc.output, tc.handlerErr).
-				Maybe()
-			svcBOS.EXPECT().
-				ClientOnlineHandler(mock.Anything, tc.input.SnacOut, mock.Anything, mock.Anything).
-				Return(tc.handlerErr).
-				Maybe()
-
-			router := server.OServiceChatRouter{
-				OServiceRouter: server.OServiceRouter{
-					OServiceHandler: svc,
-					RouteLogger: server.RouteLogger{
-						Logger: server.NewLogger(server.Config{}),
-					},
-				},
-				OServiceChatHandler: svcBOS,
-			}
-
-			bufIn := &bytes.Buffer{}
-			assert.NoError(t, oscar.Marshal(tc.input.SnacOut, bufIn))
-
-			bufOut := &bytes.Buffer{}
-			seq := uint32(1)
-
-			err := router.RouteOService(nil, nil, "", tc.input.SnacFrame, bufIn, bufOut, &seq)
-			assert.ErrorIs(t, err, tc.expectErr)
-			if tc.expectErr != nil {
-				return
-			}
-
-			if tc.output == (oscar.XMessage{}) {
-				// make sure no response was sent
-				assert.Empty(t, bufOut.Bytes())
-				return
-			}
-
-			// verify the FLAP frame
-			flap := oscar.FlapFrame{}
-			assert.NoError(t, oscar.Unmarshal(&flap, bufOut))
-
-			// make sure the sequence number was incremented
-			assert.Equal(t, uint32(2), seq)
-
-			flapBuf, err := flap.SNACBuffer(bufOut)
-			assert.NoError(t, err)
-
-			// verify the SNAC frame
-			snacFrame := oscar.SnacFrame{}
-			assert.NoError(t, oscar.Unmarshal(&snacFrame, flapBuf))
-			assert.Equal(t, tc.output.SnacFrame, snacFrame)
-
-			// verify the SNAC message
-			snacBuf := &bytes.Buffer{}
-			assert.NoError(t, oscar.Marshal(tc.output.SnacOut, snacBuf))
-			assert.Equal(t, snacBuf.Bytes(), flapBuf.Bytes())
-		})
-	}
-}

handler/profile_manager_mock.go

@@ -4,21 +4,21 @@ package handler
 
 import mock "github.com/stretchr/testify/mock"
 
-// MockProfileManager is an autogenerated mock type for the ProfileManager type
-type MockProfileManager struct {
+// mockProfileManager is an autogenerated mock type for the ProfileManager type
+type mockProfileManager struct {
 	mock.Mock
 }
 
-type MockProfileManager_Expecter struct {
+type mockProfileManager_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockProfileManager) EXPECT() *MockProfileManager_Expecter {
-	return &MockProfileManager_Expecter{mock: &_m.Mock}
+func (_m *mockProfileManager) EXPECT() *mockProfileManager_Expecter {
+	return &mockProfileManager_Expecter{mock: &_m.Mock}
 }
 
 // RetrieveProfile provides a mock function with given fields: screenName
-func (_m *MockProfileManager) RetrieveProfile(screenName string) (string, error) {
+func (_m *mockProfileManager) RetrieveProfile(screenName string) (string, error) {
 	ret := _m.Called(screenName)
 
 	var r0 string
@@ -41,36 +41,36 @@ func (_m *MockProfileManager) RetrieveProfile(screenName string) (string, error)
 	return r0, r1
 }
 
-// MockProfileManager_RetrieveProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveProfile'
-type MockProfileManager_RetrieveProfile_Call struct {
+// mockProfileManager_RetrieveProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveProfile'
+type mockProfileManager_RetrieveProfile_Call struct {
 	*mock.Call
 }
 
 // RetrieveProfile is a helper method to define mock.On call
 //   - screenName string
-func (_e *MockProfileManager_Expecter) RetrieveProfile(screenName interface{}) *MockProfileManager_RetrieveProfile_Call {
-	return &MockProfileManager_RetrieveProfile_Call{Call: _e.mock.On("RetrieveProfile", screenName)}
+func (_e *mockProfileManager_Expecter) RetrieveProfile(screenName interface{}) *mockProfileManager_RetrieveProfile_Call {
+	return &mockProfileManager_RetrieveProfile_Call{Call: _e.mock.On("RetrieveProfile", screenName)}
 }
 
-func (_c *MockProfileManager_RetrieveProfile_Call) Run(run func(screenName string)) *MockProfileManager_RetrieveProfile_Call {
+func (_c *mockProfileManager_RetrieveProfile_Call) Run(run func(screenName string)) *mockProfileManager_RetrieveProfile_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockProfileManager_RetrieveProfile_Call) Return(_a0 string, _a1 error) *MockProfileManager_RetrieveProfile_Call {
+func (_c *mockProfileManager_RetrieveProfile_Call) Return(_a0 string, _a1 error) *mockProfileManager_RetrieveProfile_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockProfileManager_RetrieveProfile_Call) RunAndReturn(run func(string) (string, error)) *MockProfileManager_RetrieveProfile_Call {
+func (_c *mockProfileManager_RetrieveProfile_Call) RunAndReturn(run func(string) (string, error)) *mockProfileManager_RetrieveProfile_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // UpsertProfile provides a mock function with given fields: screenName, body
-func (_m *MockProfileManager) UpsertProfile(screenName string, body string) error {
+func (_m *mockProfileManager) UpsertProfile(screenName string, body string) error {
 	ret := _m.Called(screenName, body)
 
 	var r0 error
@@ -83,42 +83,42 @@ func (_m *MockProfileManager) UpsertProfile(screenName string, body string) erro
 	return r0
 }
 
-// MockProfileManager_UpsertProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertProfile'
-type MockProfileManager_UpsertProfile_Call struct {
+// mockProfileManager_UpsertProfile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertProfile'
+type mockProfileManager_UpsertProfile_Call struct {
 	*mock.Call
 }
 
 // UpsertProfile is a helper method to define mock.On call
 //   - screenName string
 //   - body string
-func (_e *MockProfileManager_Expecter) UpsertProfile(screenName interface{}, body interface{}) *MockProfileManager_UpsertProfile_Call {
-	return &MockProfileManager_UpsertProfile_Call{Call: _e.mock.On("UpsertProfile", screenName, body)}
+func (_e *mockProfileManager_Expecter) UpsertProfile(screenName interface{}, body interface{}) *mockProfileManager_UpsertProfile_Call {
+	return &mockProfileManager_UpsertProfile_Call{Call: _e.mock.On("UpsertProfile", screenName, body)}
 }
 
-func (_c *MockProfileManager_UpsertProfile_Call) Run(run func(screenName string, body string)) *MockProfileManager_UpsertProfile_Call {
+func (_c *mockProfileManager_UpsertProfile_Call) Run(run func(screenName string, body string)) *mockProfileManager_UpsertProfile_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string), args[1].(string))
 	})
 	return _c
 }
 
-func (_c *MockProfileManager_UpsertProfile_Call) Return(_a0 error) *MockProfileManager_UpsertProfile_Call {
+func (_c *mockProfileManager_UpsertProfile_Call) Return(_a0 error) *mockProfileManager_UpsertProfile_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockProfileManager_UpsertProfile_Call) RunAndReturn(run func(string, string) error) *MockProfileManager_UpsertProfile_Call {
+func (_c *mockProfileManager_UpsertProfile_Call) RunAndReturn(run func(string, string) error) *mockProfileManager_UpsertProfile_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockProfileManager creates a new instance of MockProfileManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockProfileManager creates a new instance of mockProfileManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockProfileManager(t interface {
+func newMockProfileManager(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockProfileManager {
-	mock := &MockProfileManager{}
+}) *mockProfileManager {
+	mock := &mockProfileManager{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

handler/session_manager_mock.go

@@ -11,60 +11,60 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockSessionManager is an autogenerated mock type for the SessionManager type
-type MockSessionManager struct {
+// mockSessionManager is an autogenerated mock type for the SessionManager type
+type mockSessionManager struct {
 	mock.Mock
 }
 
-type MockSessionManager_Expecter struct {
+type mockSessionManager_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockSessionManager) EXPECT() *MockSessionManager_Expecter {
-	return &MockSessionManager_Expecter{mock: &_m.Mock}
+func (_m *mockSessionManager) EXPECT() *mockSessionManager_Expecter {
+	return &mockSessionManager_Expecter{mock: &_m.Mock}
 }
 
 // Broadcast provides a mock function with given fields: ctx, msg
-func (_m *MockSessionManager) Broadcast(ctx context.Context, msg oscar.XMessage) {
+func (_m *mockSessionManager) Broadcast(ctx context.Context, msg oscar.XMessage) {
 	_m.Called(ctx, msg)
 }
 
-// MockSessionManager_Broadcast_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Broadcast'
-type MockSessionManager_Broadcast_Call struct {
+// mockSessionManager_Broadcast_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Broadcast'
+type mockSessionManager_Broadcast_Call struct {
 	*mock.Call
 }
 
 // Broadcast is a helper method to define mock.On call
 //   - ctx context.Context
 //   - msg oscar.XMessage
-func (_e *MockSessionManager_Expecter) Broadcast(ctx interface{}, msg interface{}) *MockSessionManager_Broadcast_Call {
-	return &MockSessionManager_Broadcast_Call{Call: _e.mock.On("Broadcast", ctx, msg)}
+func (_e *mockSessionManager_Expecter) Broadcast(ctx interface{}, msg interface{}) *mockSessionManager_Broadcast_Call {
+	return &mockSessionManager_Broadcast_Call{Call: _e.mock.On("Broadcast", ctx, msg)}
 }
 
-func (_c *MockSessionManager_Broadcast_Call) Run(run func(ctx context.Context, msg oscar.XMessage)) *MockSessionManager_Broadcast_Call {
+func (_c *mockSessionManager_Broadcast_Call) Run(run func(ctx context.Context, msg oscar.XMessage)) *mockSessionManager_Broadcast_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.XMessage))
 	})
 	return _c
 }
 
-func (_c *MockSessionManager_Broadcast_Call) Return() *MockSessionManager_Broadcast_Call {
+func (_c *mockSessionManager_Broadcast_Call) Return() *mockSessionManager_Broadcast_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockSessionManager_Broadcast_Call) RunAndReturn(run func(context.Context, oscar.XMessage)) *MockSessionManager_Broadcast_Call {
+func (_c *mockSessionManager_Broadcast_Call) RunAndReturn(run func(context.Context, oscar.XMessage)) *mockSessionManager_Broadcast_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // BroadcastToScreenNames provides a mock function with given fields: ctx, screenNames, msg
-func (_m *MockSessionManager) BroadcastToScreenNames(ctx context.Context, screenNames []string, msg oscar.XMessage) {
+func (_m *mockSessionManager) BroadcastToScreenNames(ctx context.Context, screenNames []string, msg oscar.XMessage) {
 	_m.Called(ctx, screenNames, msg)
 }
 
-// MockSessionManager_BroadcastToScreenNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastToScreenNames'
-type MockSessionManager_BroadcastToScreenNames_Call struct {
+// mockSessionManager_BroadcastToScreenNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastToScreenNames'
+type mockSessionManager_BroadcastToScreenNames_Call struct {
 	*mock.Call
 }
 
@@ -72,29 +72,29 @@ type MockSessionManager_BroadcastToScreenNames_Call struct {
 //   - ctx context.Context
 //   - screenNames []string
 //   - msg oscar.XMessage
-func (_e *MockSessionManager_Expecter) BroadcastToScreenNames(ctx interface{}, screenNames interface{}, msg interface{}) *MockSessionManager_BroadcastToScreenNames_Call {
-	return &MockSessionManager_BroadcastToScreenNames_Call{Call: _e.mock.On("BroadcastToScreenNames", ctx, screenNames, msg)}
+func (_e *mockSessionManager_Expecter) BroadcastToScreenNames(ctx interface{}, screenNames interface{}, msg interface{}) *mockSessionManager_BroadcastToScreenNames_Call {
+	return &mockSessionManager_BroadcastToScreenNames_Call{Call: _e.mock.On("BroadcastToScreenNames", ctx, screenNames, msg)}
 }
 
-func (_c *MockSessionManager_BroadcastToScreenNames_Call) Run(run func(ctx context.Context, screenNames []string, msg oscar.XMessage)) *MockSessionManager_BroadcastToScreenNames_Call {
+func (_c *mockSessionManager_BroadcastToScreenNames_Call) Run(run func(ctx context.Context, screenNames []string, msg oscar.XMessage)) *mockSessionManager_BroadcastToScreenNames_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].([]string), args[2].(oscar.XMessage))
 	})
 	return _c
 }
 
-func (_c *MockSessionManager_BroadcastToScreenNames_Call) Return() *MockSessionManager_BroadcastToScreenNames_Call {
+func (_c *mockSessionManager_BroadcastToScreenNames_Call) Return() *mockSessionManager_BroadcastToScreenNames_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockSessionManager_BroadcastToScreenNames_Call) RunAndReturn(run func(context.Context, []string, oscar.XMessage)) *MockSessionManager_BroadcastToScreenNames_Call {
+func (_c *mockSessionManager_BroadcastToScreenNames_Call) RunAndReturn(run func(context.Context, []string, oscar.XMessage)) *mockSessionManager_BroadcastToScreenNames_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Empty provides a mock function with given fields:
-func (_m *MockSessionManager) Empty() bool {
+func (_m *mockSessionManager) Empty() bool {
 	ret := _m.Called()
 
 	var r0 bool
@@ -107,35 +107,35 @@ func (_m *MockSessionManager) Empty() bool {
 	return r0
 }
 
-// MockSessionManager_Empty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Empty'
-type MockSessionManager_Empty_Call struct {
+// mockSessionManager_Empty_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Empty'
+type mockSessionManager_Empty_Call struct {
 	*mock.Call
 }
 
 // Empty is a helper method to define mock.On call
-func (_e *MockSessionManager_Expecter) Empty() *MockSessionManager_Empty_Call {
-	return &MockSessionManager_Empty_Call{Call: _e.mock.On("Empty")}
+func (_e *mockSessionManager_Expecter) Empty() *mockSessionManager_Empty_Call {
+	return &mockSessionManager_Empty_Call{Call: _e.mock.On("Empty")}
 }
 
-func (_c *MockSessionManager_Empty_Call) Run(run func()) *MockSessionManager_Empty_Call {
+func (_c *mockSessionManager_Empty_Call) Run(run func()) *mockSessionManager_Empty_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run()
 	})
 	return _c
 }
 
-func (_c *MockSessionManager_Empty_Call) Return(_a0 bool) *MockSessionManager_Empty_Call {
+func (_c *mockSessionManager_Empty_Call) Return(_a0 bool) *mockSessionManager_Empty_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockSessionManager_Empty_Call) RunAndReturn(run func() bool) *MockSessionManager_Empty_Call {
+func (_c *mockSessionManager_Empty_Call) RunAndReturn(run func() bool) *mockSessionManager_Empty_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // NewSessionWithSN provides a mock function with given fields: sessID, screenName
-func (_m *MockSessionManager) NewSessionWithSN(sessID string, screenName string) *state.Session {
+func (_m *mockSessionManager) NewSessionWithSN(sessID string, screenName string) *state.Session {
 	ret := _m.Called(sessID, screenName)
 
 	var r0 *state.Session
@@ -150,70 +150,70 @@ func (_m *MockSessionManager) NewSessionWithSN(sessID string, screenName string)
 	return r0
 }
 
-// MockSessionManager_NewSessionWithSN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSessionWithSN'
-type MockSessionManager_NewSessionWithSN_Call struct {
+// mockSessionManager_NewSessionWithSN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewSessionWithSN'
+type mockSessionManager_NewSessionWithSN_Call struct {
 	*mock.Call
 }
 
 // NewSessionWithSN is a helper method to define mock.On call
 //   - sessID string
 //   - screenName string
-func (_e *MockSessionManager_Expecter) NewSessionWithSN(sessID interface{}, screenName interface{}) *MockSessionManager_NewSessionWithSN_Call {
-	return &MockSessionManager_NewSessionWithSN_Call{Call: _e.mock.On("NewSessionWithSN", sessID, screenName)}
+func (_e *mockSessionManager_Expecter) NewSessionWithSN(sessID interface{}, screenName interface{}) *mockSessionManager_NewSessionWithSN_Call {
+	return &mockSessionManager_NewSessionWithSN_Call{Call: _e.mock.On("NewSessionWithSN", sessID, screenName)}
 }
 
-func (_c *MockSessionManager_NewSessionWithSN_Call) Run(run func(sessID string, screenName string)) *MockSessionManager_NewSessionWithSN_Call {
+func (_c *mockSessionManager_NewSessionWithSN_Call) Run(run func(sessID string, screenName string)) *mockSessionManager_NewSessionWithSN_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string), args[1].(string))
 	})
 	return _c
 }
 
-func (_c *MockSessionManager_NewSessionWithSN_Call) Return(_a0 *state.Session) *MockSessionManager_NewSessionWithSN_Call {
+func (_c *mockSessionManager_NewSessionWithSN_Call) Return(_a0 *state.Session) *mockSessionManager_NewSessionWithSN_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockSessionManager_NewSessionWithSN_Call) RunAndReturn(run func(string, string) *state.Session) *MockSessionManager_NewSessionWithSN_Call {
+func (_c *mockSessionManager_NewSessionWithSN_Call) RunAndReturn(run func(string, string) *state.Session) *mockSessionManager_NewSessionWithSN_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Remove provides a mock function with given fields: sess
-func (_m *MockSessionManager) Remove(sess *state.Session) {
+func (_m *mockSessionManager) Remove(sess *state.Session) {
 	_m.Called(sess)
 }
 
-// MockSessionManager_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
-type MockSessionManager_Remove_Call struct {
+// mockSessionManager_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'
+type mockSessionManager_Remove_Call struct {
 	*mock.Call
 }
 
 // Remove is a helper method to define mock.On call
 //   - sess *state.Session
-func (_e *MockSessionManager_Expecter) Remove(sess interface{}) *MockSessionManager_Remove_Call {
-	return &MockSessionManager_Remove_Call{Call: _e.mock.On("Remove", sess)}
+func (_e *mockSessionManager_Expecter) Remove(sess interface{}) *mockSessionManager_Remove_Call {
+	return &mockSessionManager_Remove_Call{Call: _e.mock.On("Remove", sess)}
 }
 
-func (_c *MockSessionManager_Remove_Call) Run(run func(sess *state.Session)) *MockSessionManager_Remove_Call {
+func (_c *mockSessionManager_Remove_Call) Run(run func(sess *state.Session)) *mockSessionManager_Remove_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(*state.Session))
 	})
 	return _c
 }
 
-func (_c *MockSessionManager_Remove_Call) Return() *MockSessionManager_Remove_Call {
+func (_c *mockSessionManager_Remove_Call) Return() *mockSessionManager_Remove_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockSessionManager_Remove_Call) RunAndReturn(run func(*state.Session)) *MockSessionManager_Remove_Call {
+func (_c *mockSessionManager_Remove_Call) RunAndReturn(run func(*state.Session)) *mockSessionManager_Remove_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Retrieve provides a mock function with given fields: ID
-func (_m *MockSessionManager) Retrieve(ID string) (*state.Session, bool) {
+func (_m *mockSessionManager) Retrieve(ID string) (*state.Session, bool) {
 	ret := _m.Called(ID)
 
 	var r0 *state.Session
@@ -238,36 +238,36 @@ func (_m *MockSessionManager) Retrieve(ID string) (*state.Session, bool) {
 	return r0, r1
 }
 
-// MockSessionManager_Retrieve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Retrieve'
-type MockSessionManager_Retrieve_Call struct {
+// mockSessionManager_Retrieve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Retrieve'
+type mockSessionManager_Retrieve_Call struct {
 	*mock.Call
 }
 
 // Retrieve is a helper method to define mock.On call
 //   - ID string
-func (_e *MockSessionManager_Expecter) Retrieve(ID interface{}) *MockSessionManager_Retrieve_Call {
-	return &MockSessionManager_Retrieve_Call{Call: _e.mock.On("Retrieve", ID)}
+func (_e *mockSessionManager_Expecter) Retrieve(ID interface{}) *mockSessionManager_Retrieve_Call {
+	return &mockSessionManager_Retrieve_Call{Call: _e.mock.On("Retrieve", ID)}
 }
 
-func (_c *MockSessionManager_Retrieve_Call) Run(run func(ID string)) *MockSessionManager_Retrieve_Call {
+func (_c *mockSessionManager_Retrieve_Call) Run(run func(ID string)) *mockSessionManager_Retrieve_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockSessionManager_Retrieve_Call) Return(_a0 *state.Session, _a1 bool) *MockSessionManager_Retrieve_Call {
+func (_c *mockSessionManager_Retrieve_Call) Return(_a0 *state.Session, _a1 bool) *mockSessionManager_Retrieve_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockSessionManager_Retrieve_Call) RunAndReturn(run func(string) (*state.Session, bool)) *MockSessionManager_Retrieve_Call {
+func (_c *mockSessionManager_Retrieve_Call) RunAndReturn(run func(string) (*state.Session, bool)) *mockSessionManager_Retrieve_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RetrieveByScreenName provides a mock function with given fields: screenName
-func (_m *MockSessionManager) RetrieveByScreenName(screenName string) *state.Session {
+func (_m *mockSessionManager) RetrieveByScreenName(screenName string) *state.Session {
 	ret := _m.Called(screenName)
 
 	var r0 *state.Session
@@ -282,41 +282,41 @@ func (_m *MockSessionManager) RetrieveByScreenName(screenName string) *state.Ses
 	return r0
 }
 
-// MockSessionManager_RetrieveByScreenName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByScreenName'
-type MockSessionManager_RetrieveByScreenName_Call struct {
+// mockSessionManager_RetrieveByScreenName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByScreenName'
+type mockSessionManager_RetrieveByScreenName_Call struct {
 	*mock.Call
 }
 
 // RetrieveByScreenName is a helper method to define mock.On call
 //   - screenName string
-func (_e *MockSessionManager_Expecter) RetrieveByScreenName(screenName interface{}) *MockSessionManager_RetrieveByScreenName_Call {
-	return &MockSessionManager_RetrieveByScreenName_Call{Call: _e.mock.On("RetrieveByScreenName", screenName)}
+func (_e *mockSessionManager_Expecter) RetrieveByScreenName(screenName interface{}) *mockSessionManager_RetrieveByScreenName_Call {
+	return &mockSessionManager_RetrieveByScreenName_Call{Call: _e.mock.On("RetrieveByScreenName", screenName)}
 }
 
-func (_c *MockSessionManager_RetrieveByScreenName_Call) Run(run func(screenName string)) *MockSessionManager_RetrieveByScreenName_Call {
+func (_c *mockSessionManager_RetrieveByScreenName_Call) Run(run func(screenName string)) *mockSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockSessionManager_RetrieveByScreenName_Call) Return(_a0 *state.Session) *MockSessionManager_RetrieveByScreenName_Call {
+func (_c *mockSessionManager_RetrieveByScreenName_Call) Return(_a0 *state.Session) *mockSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockSessionManager_RetrieveByScreenName_Call) RunAndReturn(run func(string) *state.Session) *MockSessionManager_RetrieveByScreenName_Call {
+func (_c *mockSessionManager_RetrieveByScreenName_Call) RunAndReturn(run func(string) *state.Session) *mockSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // SendToScreenName provides a mock function with given fields: ctx, screenName, msg
-func (_m *MockSessionManager) SendToScreenName(ctx context.Context, screenName string, msg oscar.XMessage) {
+func (_m *mockSessionManager) SendToScreenName(ctx context.Context, screenName string, msg oscar.XMessage) {
 	_m.Called(ctx, screenName, msg)
 }
 
-// MockSessionManager_SendToScreenName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendToScreenName'
-type MockSessionManager_SendToScreenName_Call struct {
+// mockSessionManager_SendToScreenName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendToScreenName'
+type mockSessionManager_SendToScreenName_Call struct {
 	*mock.Call
 }
 
@@ -324,34 +324,34 @@ type MockSessionManager_SendToScreenName_Call struct {
 //   - ctx context.Context
 //   - screenName string
 //   - msg oscar.XMessage
-func (_e *MockSessionManager_Expecter) SendToScreenName(ctx interface{}, screenName interface{}, msg interface{}) *MockSessionManager_SendToScreenName_Call {
-	return &MockSessionManager_SendToScreenName_Call{Call: _e.mock.On("SendToScreenName", ctx, screenName, msg)}
+func (_e *mockSessionManager_Expecter) SendToScreenName(ctx interface{}, screenName interface{}, msg interface{}) *mockSessionManager_SendToScreenName_Call {
+	return &mockSessionManager_SendToScreenName_Call{Call: _e.mock.On("SendToScreenName", ctx, screenName, msg)}
 }
 
-func (_c *MockSessionManager_SendToScreenName_Call) Run(run func(ctx context.Context, screenName string, msg oscar.XMessage)) *MockSessionManager_SendToScreenName_Call {
+func (_c *mockSessionManager_SendToScreenName_Call) Run(run func(ctx context.Context, screenName string, msg oscar.XMessage)) *mockSessionManager_SendToScreenName_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(string), args[2].(oscar.XMessage))
 	})
 	return _c
 }
 
-func (_c *MockSessionManager_SendToScreenName_Call) Return() *MockSessionManager_SendToScreenName_Call {
+func (_c *mockSessionManager_SendToScreenName_Call) Return() *mockSessionManager_SendToScreenName_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockSessionManager_SendToScreenName_Call) RunAndReturn(run func(context.Context, string, oscar.XMessage)) *MockSessionManager_SendToScreenName_Call {
+func (_c *mockSessionManager_SendToScreenName_Call) RunAndReturn(run func(context.Context, string, oscar.XMessage)) *mockSessionManager_SendToScreenName_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockSessionManager creates a new instance of MockSessionManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockSessionManager creates a new instance of mockSessionManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockSessionManager(t interface {
+func newMockSessionManager(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockSessionManager {
-	mock := &MockSessionManager{}
+}) *mockSessionManager {
+	mock := &mockSessionManager{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

handler/user_manager_manager_mock.go

@@ -7,21 +7,21 @@ import (
 	mock "github.com/stretchr/testify/mock"
 )
 
-// MockUserManager is an autogenerated mock type for the UserManager type
-type MockUserManager struct {
+// mockUserManager is an autogenerated mock type for the UserManager type
+type mockUserManager struct {
 	mock.Mock
 }
 
-type MockUserManager_Expecter struct {
+type mockUserManager_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockUserManager) EXPECT() *MockUserManager_Expecter {
-	return &MockUserManager_Expecter{mock: &_m.Mock}
+func (_m *mockUserManager) EXPECT() *mockUserManager_Expecter {
+	return &mockUserManager_Expecter{mock: &_m.Mock}
 }
 
 // GetUser provides a mock function with given fields: screenName
-func (_m *MockUserManager) GetUser(screenName string) (*state.User, error) {
+func (_m *mockUserManager) GetUser(screenName string) (*state.User, error) {
 	ret := _m.Called(screenName)
 
 	var r0 *state.User
@@ -46,36 +46,36 @@ func (_m *MockUserManager) GetUser(screenName string) (*state.User, error) {
 	return r0, r1
 }
 
-// MockUserManager_GetUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUser'
-type MockUserManager_GetUser_Call struct {
+// mockUserManager_GetUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUser'
+type mockUserManager_GetUser_Call struct {
 	*mock.Call
 }
 
 // GetUser is a helper method to define mock.On call
 //   - screenName string
-func (_e *MockUserManager_Expecter) GetUser(screenName interface{}) *MockUserManager_GetUser_Call {
-	return &MockUserManager_GetUser_Call{Call: _e.mock.On("GetUser", screenName)}
+func (_e *mockUserManager_Expecter) GetUser(screenName interface{}) *mockUserManager_GetUser_Call {
+	return &mockUserManager_GetUser_Call{Call: _e.mock.On("GetUser", screenName)}
 }
 
-func (_c *MockUserManager_GetUser_Call) Run(run func(screenName string)) *MockUserManager_GetUser_Call {
+func (_c *mockUserManager_GetUser_Call) Run(run func(screenName string)) *mockUserManager_GetUser_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(string))
 	})
 	return _c
 }
 
-func (_c *MockUserManager_GetUser_Call) Return(_a0 *state.User, _a1 error) *MockUserManager_GetUser_Call {
+func (_c *mockUserManager_GetUser_Call) Return(_a0 *state.User, _a1 error) *mockUserManager_GetUser_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockUserManager_GetUser_Call) RunAndReturn(run func(string) (*state.User, error)) *MockUserManager_GetUser_Call {
+func (_c *mockUserManager_GetUser_Call) RunAndReturn(run func(string) (*state.User, error)) *mockUserManager_GetUser_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // UpsertUser provides a mock function with given fields: u
-func (_m *MockUserManager) UpsertUser(u state.User) error {
+func (_m *mockUserManager) UpsertUser(u state.User) error {
 	ret := _m.Called(u)
 
 	var r0 error
@@ -88,41 +88,41 @@ func (_m *MockUserManager) UpsertUser(u state.User) error {
 	return r0
 }
 
-// MockUserManager_UpsertUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertUser'
-type MockUserManager_UpsertUser_Call struct {
+// mockUserManager_UpsertUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertUser'
+type mockUserManager_UpsertUser_Call struct {
 	*mock.Call
 }
 
 // UpsertUser is a helper method to define mock.On call
 //   - u state.User
-func (_e *MockUserManager_Expecter) UpsertUser(u interface{}) *MockUserManager_UpsertUser_Call {
-	return &MockUserManager_UpsertUser_Call{Call: _e.mock.On("UpsertUser", u)}
+func (_e *mockUserManager_Expecter) UpsertUser(u interface{}) *mockUserManager_UpsertUser_Call {
+	return &mockUserManager_UpsertUser_Call{Call: _e.mock.On("UpsertUser", u)}
 }
 
-func (_c *MockUserManager_UpsertUser_Call) Run(run func(u state.User)) *MockUserManager_UpsertUser_Call {
+func (_c *mockUserManager_UpsertUser_Call) Run(run func(u state.User)) *mockUserManager_UpsertUser_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(state.User))
 	})
 	return _c
 }
 
-func (_c *MockUserManager_UpsertUser_Call) Return(_a0 error) *MockUserManager_UpsertUser_Call {
+func (_c *mockUserManager_UpsertUser_Call) Return(_a0 error) *mockUserManager_UpsertUser_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockUserManager_UpsertUser_Call) RunAndReturn(run func(state.User) error) *MockUserManager_UpsertUser_Call {
+func (_c *mockUserManager_UpsertUser_Call) RunAndReturn(run func(state.User) error) *mockUserManager_UpsertUser_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockUserManager creates a new instance of MockUserManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockUserManager creates a new instance of mockUserManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockUserManager(t interface {
+func newMockUserManager(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockUserManager {
-	mock := &MockUserManager{}
+}) *mockUserManager {
+	mock := &mockUserManager{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/buddy_mock.go

@@ -9,21 +9,21 @@ import (
 	mock "github.com/stretchr/testify/mock"
 )
 
-// MockBuddyHandler is an autogenerated mock type for the BuddyHandler type
-type MockBuddyHandler struct {
+// mockBuddyHandler is an autogenerated mock type for the BuddyHandler type
+type mockBuddyHandler struct {
 	mock.Mock
 }
 
-type MockBuddyHandler_Expecter struct {
+type mockBuddyHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockBuddyHandler) EXPECT() *MockBuddyHandler_Expecter {
-	return &MockBuddyHandler_Expecter{mock: &_m.Mock}
+func (_m *mockBuddyHandler) EXPECT() *mockBuddyHandler_Expecter {
+	return &mockBuddyHandler_Expecter{mock: &_m.Mock}
 }
 
 // RightsQueryHandler provides a mock function with given fields: ctx
-func (_m *MockBuddyHandler) RightsQueryHandler(ctx context.Context) oscar.XMessage {
+func (_m *mockBuddyHandler) RightsQueryHandler(ctx context.Context) oscar.XMessage {
 	ret := _m.Called(ctx)
 
 	var r0 oscar.XMessage
@@ -36,41 +36,41 @@ func (_m *MockBuddyHandler) RightsQueryHandler(ctx context.Context) oscar.XMessa
 	return r0
 }
 
-// MockBuddyHandler_RightsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RightsQueryHandler'
-type MockBuddyHandler_RightsQueryHandler_Call struct {
+// mockBuddyHandler_RightsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RightsQueryHandler'
+type mockBuddyHandler_RightsQueryHandler_Call struct {
 	*mock.Call
 }
 
 // RightsQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-func (_e *MockBuddyHandler_Expecter) RightsQueryHandler(ctx interface{}) *MockBuddyHandler_RightsQueryHandler_Call {
-	return &MockBuddyHandler_RightsQueryHandler_Call{Call: _e.mock.On("RightsQueryHandler", ctx)}
+func (_e *mockBuddyHandler_Expecter) RightsQueryHandler(ctx interface{}) *mockBuddyHandler_RightsQueryHandler_Call {
+	return &mockBuddyHandler_RightsQueryHandler_Call{Call: _e.mock.On("RightsQueryHandler", ctx)}
 }
 
-func (_c *MockBuddyHandler_RightsQueryHandler_Call) Run(run func(ctx context.Context)) *MockBuddyHandler_RightsQueryHandler_Call {
+func (_c *mockBuddyHandler_RightsQueryHandler_Call) Run(run func(ctx context.Context)) *mockBuddyHandler_RightsQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockBuddyHandler_RightsQueryHandler_Call) Return(_a0 oscar.XMessage) *MockBuddyHandler_RightsQueryHandler_Call {
+func (_c *mockBuddyHandler_RightsQueryHandler_Call) Return(_a0 oscar.XMessage) *mockBuddyHandler_RightsQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockBuddyHandler_RightsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockBuddyHandler_RightsQueryHandler_Call {
+func (_c *mockBuddyHandler_RightsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockBuddyHandler_RightsQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockBuddyHandler creates a new instance of MockBuddyHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockBuddyHandler creates a new instance of mockBuddyHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockBuddyHandler(t interface {
+func newMockBuddyHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockBuddyHandler {
-	mock := &MockBuddyHandler{}
+}) *mockBuddyHandler {
+	mock := &mockBuddyHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/buddy_test.go

@@ -72,7 +72,7 @@ func TestBuddyRouter_RouteBuddy(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svc := NewMockBuddyHandler(t)
+			svc := newMockBuddyHandler(t)
 			svc.EXPECT().
 				RightsQueryHandler(mock.Anything).
 				Return(tc.output).

server/chat_mock.go

@@ -11,21 +11,21 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockChatHandler is an autogenerated mock type for the ChatHandler type
-type MockChatHandler struct {
+// mockChatHandler is an autogenerated mock type for the ChatHandler type
+type mockChatHandler struct {
 	mock.Mock
 }
 
-type MockChatHandler_Expecter struct {
+type mockChatHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockChatHandler) EXPECT() *MockChatHandler_Expecter {
-	return &MockChatHandler_Expecter{mock: &_m.Mock}
+func (_m *mockChatHandler) EXPECT() *mockChatHandler_Expecter {
+	return &mockChatHandler_Expecter{mock: &_m.Mock}
 }
 
 // ChannelMsgToHostHandler provides a mock function with given fields: ctx, sess, chatID, snacPayloadIn
-func (_m *MockChatHandler) ChannelMsgToHostHandler(ctx context.Context, sess *state.Session, chatID string, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error) {
+func (_m *mockChatHandler) ChannelMsgToHostHandler(ctx context.Context, sess *state.Session, chatID string, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, chatID, snacPayloadIn)
 
 	var r0 *oscar.XMessage
@@ -50,8 +50,8 @@ func (_m *MockChatHandler) ChannelMsgToHostHandler(ctx context.Context, sess *st
 	return r0, r1
 }
 
-// MockChatHandler_ChannelMsgToHostHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelMsgToHostHandler'
-type MockChatHandler_ChannelMsgToHostHandler_Call struct {
+// mockChatHandler_ChannelMsgToHostHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelMsgToHostHandler'
+type mockChatHandler_ChannelMsgToHostHandler_Call struct {
 	*mock.Call
 }
 
@@ -60,34 +60,34 @@ type MockChatHandler_ChannelMsgToHostHandler_Call struct {
 //   - sess *state.Session
 //   - chatID string
 //   - snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost
-func (_e *MockChatHandler_Expecter) ChannelMsgToHostHandler(ctx interface{}, sess interface{}, chatID interface{}, snacPayloadIn interface{}) *MockChatHandler_ChannelMsgToHostHandler_Call {
-	return &MockChatHandler_ChannelMsgToHostHandler_Call{Call: _e.mock.On("ChannelMsgToHostHandler", ctx, sess, chatID, snacPayloadIn)}
+func (_e *mockChatHandler_Expecter) ChannelMsgToHostHandler(ctx interface{}, sess interface{}, chatID interface{}, snacPayloadIn interface{}) *mockChatHandler_ChannelMsgToHostHandler_Call {
+	return &mockChatHandler_ChannelMsgToHostHandler_Call{Call: _e.mock.On("ChannelMsgToHostHandler", ctx, sess, chatID, snacPayloadIn)}
 }
 
-func (_c *MockChatHandler_ChannelMsgToHostHandler_Call) Run(run func(ctx context.Context, sess *state.Session, chatID string, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost)) *MockChatHandler_ChannelMsgToHostHandler_Call {
+func (_c *mockChatHandler_ChannelMsgToHostHandler_Call) Run(run func(ctx context.Context, sess *state.Session, chatID string, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost)) *mockChatHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(string), args[3].(oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost))
 	})
 	return _c
 }
 
-func (_c *MockChatHandler_ChannelMsgToHostHandler_Call) Return(_a0 *oscar.XMessage, _a1 error) *MockChatHandler_ChannelMsgToHostHandler_Call {
+func (_c *mockChatHandler_ChannelMsgToHostHandler_Call) Return(_a0 *oscar.XMessage, _a1 error) *mockChatHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockChatHandler_ChannelMsgToHostHandler_Call) RunAndReturn(run func(context.Context, *state.Session, string, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error)) *MockChatHandler_ChannelMsgToHostHandler_Call {
+func (_c *mockChatHandler_ChannelMsgToHostHandler_Call) RunAndReturn(run func(context.Context, *state.Session, string, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error)) *mockChatHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockChatHandler creates a new instance of MockChatHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockChatHandler creates a new instance of mockChatHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockChatHandler(t interface {
+func newMockChatHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockChatHandler {
-	mock := &MockChatHandler{}
+}) *mockChatHandler {
+	mock := &mockChatHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/chat_nav_mock.go

@@ -11,21 +11,21 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockChatNavHandler is an autogenerated mock type for the ChatNavHandler type
-type MockChatNavHandler struct {
+// mockChatNavHandler is an autogenerated mock type for the ChatNavHandler type
+type mockChatNavHandler struct {
 	mock.Mock
 }
 
-type MockChatNavHandler_Expecter struct {
+type mockChatNavHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockChatNavHandler) EXPECT() *MockChatNavHandler_Expecter {
-	return &MockChatNavHandler_Expecter{mock: &_m.Mock}
+func (_m *mockChatNavHandler) EXPECT() *mockChatNavHandler_Expecter {
+	return &mockChatNavHandler_Expecter{mock: &_m.Mock}
 }
 
 // CreateRoomHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockChatNavHandler) CreateRoomHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error) {
+func (_m *mockChatNavHandler) CreateRoomHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -48,8 +48,8 @@ func (_m *MockChatNavHandler) CreateRoomHandler(ctx context.Context, sess *state
 	return r0, r1
 }
 
-// MockChatNavHandler_CreateRoomHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoomHandler'
-type MockChatNavHandler_CreateRoomHandler_Call struct {
+// mockChatNavHandler_CreateRoomHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRoomHandler'
+type mockChatNavHandler_CreateRoomHandler_Call struct {
 	*mock.Call
 }
 
@@ -57,29 +57,29 @@ type MockChatNavHandler_CreateRoomHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate
-func (_e *MockChatNavHandler_Expecter) CreateRoomHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockChatNavHandler_CreateRoomHandler_Call {
-	return &MockChatNavHandler_CreateRoomHandler_Call{Call: _e.mock.On("CreateRoomHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockChatNavHandler_Expecter) CreateRoomHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockChatNavHandler_CreateRoomHandler_Call {
+	return &mockChatNavHandler_CreateRoomHandler_Call{Call: _e.mock.On("CreateRoomHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockChatNavHandler_CreateRoomHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate)) *MockChatNavHandler_CreateRoomHandler_Call {
+func (_c *mockChatNavHandler_CreateRoomHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate)) *mockChatNavHandler_CreateRoomHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate))
 	})
 	return _c
 }
 
-func (_c *MockChatNavHandler_CreateRoomHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockChatNavHandler_CreateRoomHandler_Call {
+func (_c *mockChatNavHandler_CreateRoomHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockChatNavHandler_CreateRoomHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockChatNavHandler_CreateRoomHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error)) *MockChatNavHandler_CreateRoomHandler_Call {
+func (_c *mockChatNavHandler_CreateRoomHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error)) *mockChatNavHandler_CreateRoomHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RequestChatRightsHandler provides a mock function with given fields: ctx
-func (_m *MockChatNavHandler) RequestChatRightsHandler(ctx context.Context) oscar.XMessage {
+func (_m *mockChatNavHandler) RequestChatRightsHandler(ctx context.Context) oscar.XMessage {
 	ret := _m.Called(ctx)
 
 	var r0 oscar.XMessage
@@ -92,36 +92,36 @@ func (_m *MockChatNavHandler) RequestChatRightsHandler(ctx context.Context) osca
 	return r0
 }
 
-// MockChatNavHandler_RequestChatRightsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestChatRightsHandler'
-type MockChatNavHandler_RequestChatRightsHandler_Call struct {
+// mockChatNavHandler_RequestChatRightsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestChatRightsHandler'
+type mockChatNavHandler_RequestChatRightsHandler_Call struct {
 	*mock.Call
 }
 
 // RequestChatRightsHandler is a helper method to define mock.On call
 //   - ctx context.Context
-func (_e *MockChatNavHandler_Expecter) RequestChatRightsHandler(ctx interface{}) *MockChatNavHandler_RequestChatRightsHandler_Call {
-	return &MockChatNavHandler_RequestChatRightsHandler_Call{Call: _e.mock.On("RequestChatRightsHandler", ctx)}
+func (_e *mockChatNavHandler_Expecter) RequestChatRightsHandler(ctx interface{}) *mockChatNavHandler_RequestChatRightsHandler_Call {
+	return &mockChatNavHandler_RequestChatRightsHandler_Call{Call: _e.mock.On("RequestChatRightsHandler", ctx)}
 }
 
-func (_c *MockChatNavHandler_RequestChatRightsHandler_Call) Run(run func(ctx context.Context)) *MockChatNavHandler_RequestChatRightsHandler_Call {
+func (_c *mockChatNavHandler_RequestChatRightsHandler_Call) Run(run func(ctx context.Context)) *mockChatNavHandler_RequestChatRightsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockChatNavHandler_RequestChatRightsHandler_Call) Return(_a0 oscar.XMessage) *MockChatNavHandler_RequestChatRightsHandler_Call {
+func (_c *mockChatNavHandler_RequestChatRightsHandler_Call) Return(_a0 oscar.XMessage) *mockChatNavHandler_RequestChatRightsHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockChatNavHandler_RequestChatRightsHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockChatNavHandler_RequestChatRightsHandler_Call {
+func (_c *mockChatNavHandler_RequestChatRightsHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockChatNavHandler_RequestChatRightsHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RequestRoomInfoHandler provides a mock function with given fields: ctx, snacPayloadIn
-func (_m *MockChatNavHandler) RequestRoomInfoHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo) (oscar.XMessage, error) {
+func (_m *mockChatNavHandler) RequestRoomInfoHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -144,42 +144,42 @@ func (_m *MockChatNavHandler) RequestRoomInfoHandler(ctx context.Context, snacPa
 	return r0, r1
 }
 
-// MockChatNavHandler_RequestRoomInfoHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestRoomInfoHandler'
-type MockChatNavHandler_RequestRoomInfoHandler_Call struct {
+// mockChatNavHandler_RequestRoomInfoHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestRoomInfoHandler'
+type mockChatNavHandler_RequestRoomInfoHandler_Call struct {
 	*mock.Call
 }
 
 // RequestRoomInfoHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - snacPayloadIn oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo
-func (_e *MockChatNavHandler_Expecter) RequestRoomInfoHandler(ctx interface{}, snacPayloadIn interface{}) *MockChatNavHandler_RequestRoomInfoHandler_Call {
-	return &MockChatNavHandler_RequestRoomInfoHandler_Call{Call: _e.mock.On("RequestRoomInfoHandler", ctx, snacPayloadIn)}
+func (_e *mockChatNavHandler_Expecter) RequestRoomInfoHandler(ctx interface{}, snacPayloadIn interface{}) *mockChatNavHandler_RequestRoomInfoHandler_Call {
+	return &mockChatNavHandler_RequestRoomInfoHandler_Call{Call: _e.mock.On("RequestRoomInfoHandler", ctx, snacPayloadIn)}
 }
 
-func (_c *MockChatNavHandler_RequestRoomInfoHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo)) *MockChatNavHandler_RequestRoomInfoHandler_Call {
+func (_c *mockChatNavHandler_RequestRoomInfoHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo)) *mockChatNavHandler_RequestRoomInfoHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo))
 	})
 	return _c
 }
 
-func (_c *MockChatNavHandler_RequestRoomInfoHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockChatNavHandler_RequestRoomInfoHandler_Call {
+func (_c *mockChatNavHandler_RequestRoomInfoHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockChatNavHandler_RequestRoomInfoHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockChatNavHandler_RequestRoomInfoHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo) (oscar.XMessage, error)) *MockChatNavHandler_RequestRoomInfoHandler_Call {
+func (_c *mockChatNavHandler_RequestRoomInfoHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo) (oscar.XMessage, error)) *mockChatNavHandler_RequestRoomInfoHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockChatNavHandler creates a new instance of MockChatNavHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockChatNavHandler creates a new instance of mockChatNavHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockChatNavHandler(t interface {
+func newMockChatNavHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockChatNavHandler {
-	mock := &MockChatNavHandler{}
+}) *mockChatNavHandler {
+	mock := &mockChatNavHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/chat_nav_test.go

@@ -110,7 +110,7 @@ func TestChatNavRouter_RouteChatNavRouter(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svc := NewMockChatNavHandler(t)
+			svc := newMockChatNavHandler(t)
 			svc.EXPECT().
 				RequestChatRightsHandler(mock.Anything).
 				Return(tc.output).

server/chat_test.go

@@ -72,7 +72,7 @@ func TestChatRouter_RouteChat(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svc := NewMockChatHandler(t)
+			svc := newMockChatHandler(t)
 			svc.EXPECT().
 				ChannelMsgToHostHandler(mock.Anything, mock.Anything, mock.Anything, tc.input.SnacOut).
 				Return(tc.output, tc.handlerErr).

server/connection.go

@@ -115,47 +115,37 @@ func dispatchIncomingMessages(ctx context.Context, sess *state.Session, seq uint
 	}
 }
 
-type sessionRetriever interface {
-	Retrieve(ID string) (*state.Session, bool)
-}
-
-func HandleChatConnection(ctx context.Context, cr *state.ChatRegistry, rw io.ReadWriter, router ChatServiceRouter, authHandler AuthHandler, logger *slog.Logger) {
-	cookie, seq, err := authHandler.VerifyChatLogin(rw)
+func handleChatConnection(ctx context.Context, rw io.ReadWriter, serviceManager ChatServiceManager, logger *slog.Logger) {
+	cookie, seq, err := serviceManager.VerifyChatLogin(rw)
 	if err != nil {
 		logger.ErrorContext(ctx, "user disconnected with error", "err", err.Error())
 		return
 	}
 
-	_, chatSessMgr, err := cr.Retrieve(string(cookie.Cookie))
+	chatID := string(cookie.Cookie)
+
+	chatSess, err := serviceManager.RetrieveChatSession(ctx, chatID, cookie.SessID)
 	if err != nil {
 		logger.ErrorContext(ctx, "unable to find chat room", "err", err.Error())
 		return
 	}
 
-	chatSess, found := chatSessMgr.(sessionRetriever).Retrieve(cookie.SessID)
-	if !found {
-		logger.ErrorContext(ctx, "unable to find user for session", "sessID", cookie.SessID)
-		return
-	}
-
-	chatID := string(cookie.Cookie)
-
 	defer chatSess.Close()
 	go func() {
 		<-chatSess.Closed()
-		authHandler.SignoutChat(ctx, chatSess, chatID)
+		serviceManager.SignoutChat(ctx, chatSess, chatID)
 	}()
 
 	ctx = context.WithValue(ctx, "screenName", chatSess.ScreenName())
 
-	msg := router.WriteOServiceHostOnline()
+	msg := serviceManager.WriteOServiceHostOnline()
 	if err := writeOutSNAC(oscar.SnacFrame{}, msg.SnacFrame, msg.SnacOut, &seq, rw); err != nil {
 		logger.ErrorContext(ctx, "error WriteOServiceHostOnline")
 		return
 	}
 
 	fnClientReqHandler := func(ctx context.Context, r io.Reader, w io.Writer, seq *uint32) error {
-		return router.Route(ctx, chatSess, r, w, seq, chatID)
+		return serviceManager.Route(ctx, chatSess, r, w, seq, chatID)
 	}
 	fnAlertHandler := func(ctx context.Context, msg oscar.XMessage, w io.Writer, seq *uint32) error {
 		return writeOutSNAC(oscar.SnacFrame{}, msg.SnacFrame, msg.SnacOut, seq, w)
@@ -163,7 +153,7 @@ func HandleChatConnection(ctx context.Context, cr *state.ChatRegistry, rw io.Rea
 	dispatchIncomingMessages(ctx, chatSess, seq, rw, logger, fnClientReqHandler, fnAlertHandler)
 }
 
-func HandleAuthConnection(authHandler AuthHandler, conn net.Conn) {
+func handleAuthConnection(authHandler AuthHandler, conn net.Conn) {
 	defer conn.Close()
 	seq := uint32(100)
 	_, err := authHandler.SendAndReceiveSignonFrame(conn, &seq)
@@ -239,9 +229,9 @@ func HandleAuthConnection(authHandler AuthHandler, conn net.Conn) {
 	}
 }
 
-func HandleBOSConnection(ctx context.Context, conn net.Conn, router BOSServiceRouter, authHandler AuthHandler, logger *slog.Logger) {
+func handleBOSConnection(ctx context.Context, conn net.Conn, serviceManager BOSServiceManager, logger *slog.Logger) {
 	// todo why is conn net.Conn but handleChat is rw?
-	sess, seq, err := authHandler.VerifyLogin(conn)
+	sess, seq, err := serviceManager.VerifyLogin(conn)
 	if err != nil {
 		logger.ErrorContext(ctx, "user disconnected with error", "err", err.Error())
 		return
@@ -252,21 +242,21 @@ func HandleBOSConnection(ctx context.Context, conn net.Conn, router BOSServiceRo
 
 	go func() {
 		<-sess.Closed()
-		if err := authHandler.Signout(ctx, sess); err != nil {
+		if err := serviceManager.Signout(ctx, sess); err != nil {
 			logger.ErrorContext(ctx, "error notifying departure", "err", err.Error())
 		}
 	}()
 
 	ctx = context.WithValue(ctx, "screenName", sess.ScreenName())
 
-	msg := router.WriteOServiceHostOnline()
+	msg := serviceManager.WriteOServiceHostOnline()
 	if err := writeOutSNAC(oscar.SnacFrame{}, msg.SnacFrame, msg.SnacOut, &seq, conn); err != nil {
 		logger.ErrorContext(ctx, "error WriteOServiceHostOnline")
 		return
 	}
 
 	fnClientReqHandler := func(ctx context.Context, r io.Reader, w io.Writer, seq *uint32) error {
-		return router.Route(ctx, sess, r, w, seq)
+		return serviceManager.Route(ctx, sess, r, w, seq)
 	}
 	fnAlertHandler := func(ctx context.Context, msg oscar.XMessage, w io.Writer, seq *uint32) error {
 		return writeOutSNAC(oscar.SnacFrame{}, msg.SnacFrame, msg.SnacOut, seq, w)
@@ -274,7 +264,7 @@ func HandleBOSConnection(ctx context.Context, conn net.Conn, router BOSServiceRo
 	dispatchIncomingMessages(ctx, sess, seq, conn, logger, fnClientReqHandler, fnAlertHandler)
 }
 
-func ListenChat(cfg Config, router ChatServiceRouter, cr *state.ChatRegistry, authHandler AuthHandler, logger *slog.Logger) {
+func ListenChat(cfg Config, router ChatServiceManager, logger *slog.Logger) {
 	addr := Address("", cfg.ChatPort)
 	listener, err := net.Listen("tcp", addr)
 	if err != nil {
@@ -295,13 +285,13 @@ func ListenChat(cfg Config, router ChatServiceRouter, cr *state.ChatRegistry, au
 		ctx = context.WithValue(ctx, "ip", conn.RemoteAddr().String())
 		logger.DebugContext(ctx, "accepted connection")
 		go func() {
-			HandleChatConnection(ctx, cr, conn, router, authHandler, logger)
+			handleChatConnection(ctx, conn, router, logger)
 			conn.Close()
 		}()
 	}
 }
 
-func ListenBOS(cfg Config, router BOSServiceRouter, authHandler AuthHandler, logger *slog.Logger) {
+func ListenBOS(cfg Config, router BOSServiceManager, logger *slog.Logger) {
 	addr := Address("", cfg.BOSPort)
 	listener, err := net.Listen("tcp", addr)
 	if err != nil {
@@ -321,7 +311,7 @@ func ListenBOS(cfg Config, router BOSServiceRouter, authHandler AuthHandler, log
 		ctx := context.Background()
 		ctx = context.WithValue(ctx, "ip", conn.RemoteAddr().String())
 		logger.DebugContext(ctx, "accepted connection")
-		go HandleBOSConnection(ctx, conn, router, authHandler, logger)
+		go handleBOSConnection(ctx, conn, router, logger)
 	}
 }
 
@@ -343,6 +333,6 @@ func ListenBUCPLogin(cfg Config, err error, logger *slog.Logger, authHandler Aut
 			continue
 		}
 
-		go HandleAuthConnection(authHandler, conn)
+		go handleAuthConnection(authHandler, conn)
 	}
 }

server/connection_test.go

@@ -16,15 +16,10 @@ func TestHandleChatConnection_Notification(t *testing.T) {
 
 	ctx := context.Background()
 	cfg := Config{}
-	cr := state.NewChatRegistry()
 	logger := NewLogger(cfg)
 
-	room := state.ChatRoom{
-		Name: "test chat room!",
-	}
 	sm := state.NewSessionManager(logger)
 	sess := sm.NewSessionWithSN("bob-sess-id", "bob")
-	cr.Register(room, sm)
 
 	msgIn := []oscar.XMessage{
 		{
@@ -84,15 +79,10 @@ func TestHandleChatConnection_ClientRequestFLAP(t *testing.T) {
 
 	ctx := context.Background()
 	cfg := Config{}
-	cr := state.NewChatRegistry()
 	logger := NewLogger(cfg)
 
-	room := state.ChatRoom{
-		Name: "test chat room!",
-	}
 	sm := state.NewSessionManager(logger)
 	sess := sm.NewSessionWithSN("bob-sess-id", "bob")
-	cr.Register(room, sm)
 
 	payloads := [][]byte{
 		{'a', 'b', 'c', 'd'},
@@ -144,15 +134,10 @@ func TestHandleChatConnection_SessionClosed(t *testing.T) {
 
 	ctx := context.Background()
 	cfg := Config{}
-	cr := state.NewChatRegistry()
 	logger := NewLogger(cfg)
 
-	room := state.ChatRoom{
-		Name: "test chat room!",
-	}
 	sm := state.NewSessionManager(logger)
 	sess := sm.NewSessionWithSN("bob-sess-id", "bob")
-	cr.Register(room, sm)
 
 	routeSig := func(ctx context.Context, buf io.Reader, w io.Writer, u *uint32) error {
 		t.Fatal("not expecting any output")

server/feedbag_mock.go

@@ -11,21 +11,21 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockFeedbagHandler is an autogenerated mock type for the FeedbagHandler type
-type MockFeedbagHandler struct {
+// mockFeedbagHandler is an autogenerated mock type for the FeedbagHandler type
+type mockFeedbagHandler struct {
 	mock.Mock
 }
 
-type MockFeedbagHandler_Expecter struct {
+type mockFeedbagHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockFeedbagHandler) EXPECT() *MockFeedbagHandler_Expecter {
-	return &MockFeedbagHandler_Expecter{mock: &_m.Mock}
+func (_m *mockFeedbagHandler) EXPECT() *mockFeedbagHandler_Expecter {
+	return &mockFeedbagHandler_Expecter{mock: &_m.Mock}
 }
 
 // DeleteItemHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockFeedbagHandler) DeleteItemHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error) {
+func (_m *mockFeedbagHandler) DeleteItemHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -48,8 +48,8 @@ func (_m *MockFeedbagHandler) DeleteItemHandler(ctx context.Context, sess *state
 	return r0, r1
 }
 
-// MockFeedbagHandler_DeleteItemHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteItemHandler'
-type MockFeedbagHandler_DeleteItemHandler_Call struct {
+// mockFeedbagHandler_DeleteItemHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteItemHandler'
+type mockFeedbagHandler_DeleteItemHandler_Call struct {
 	*mock.Call
 }
 
@@ -57,29 +57,29 @@ type MockFeedbagHandler_DeleteItemHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem
-func (_e *MockFeedbagHandler_Expecter) DeleteItemHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockFeedbagHandler_DeleteItemHandler_Call {
-	return &MockFeedbagHandler_DeleteItemHandler_Call{Call: _e.mock.On("DeleteItemHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockFeedbagHandler_Expecter) DeleteItemHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockFeedbagHandler_DeleteItemHandler_Call {
+	return &mockFeedbagHandler_DeleteItemHandler_Call{Call: _e.mock.On("DeleteItemHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockFeedbagHandler_DeleteItemHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem)) *MockFeedbagHandler_DeleteItemHandler_Call {
+func (_c *mockFeedbagHandler_DeleteItemHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem)) *mockFeedbagHandler_DeleteItemHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x13_0x0A_FeedbagDeleteItem))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagHandler_DeleteItemHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockFeedbagHandler_DeleteItemHandler_Call {
+func (_c *mockFeedbagHandler_DeleteItemHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockFeedbagHandler_DeleteItemHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagHandler_DeleteItemHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error)) *MockFeedbagHandler_DeleteItemHandler_Call {
+func (_c *mockFeedbagHandler_DeleteItemHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error)) *mockFeedbagHandler_DeleteItemHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // InsertItemHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockFeedbagHandler) InsertItemHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error) {
+func (_m *mockFeedbagHandler) InsertItemHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -102,8 +102,8 @@ func (_m *MockFeedbagHandler) InsertItemHandler(ctx context.Context, sess *state
 	return r0, r1
 }
 
-// MockFeedbagHandler_InsertItemHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertItemHandler'
-type MockFeedbagHandler_InsertItemHandler_Call struct {
+// mockFeedbagHandler_InsertItemHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertItemHandler'
+type mockFeedbagHandler_InsertItemHandler_Call struct {
 	*mock.Call
 }
 
@@ -111,29 +111,29 @@ type MockFeedbagHandler_InsertItemHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem
-func (_e *MockFeedbagHandler_Expecter) InsertItemHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockFeedbagHandler_InsertItemHandler_Call {
-	return &MockFeedbagHandler_InsertItemHandler_Call{Call: _e.mock.On("InsertItemHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockFeedbagHandler_Expecter) InsertItemHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockFeedbagHandler_InsertItemHandler_Call {
+	return &mockFeedbagHandler_InsertItemHandler_Call{Call: _e.mock.On("InsertItemHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockFeedbagHandler_InsertItemHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem)) *MockFeedbagHandler_InsertItemHandler_Call {
+func (_c *mockFeedbagHandler_InsertItemHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem)) *mockFeedbagHandler_InsertItemHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x13_0x08_FeedbagInsertItem))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagHandler_InsertItemHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockFeedbagHandler_InsertItemHandler_Call {
+func (_c *mockFeedbagHandler_InsertItemHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockFeedbagHandler_InsertItemHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagHandler_InsertItemHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error)) *MockFeedbagHandler_InsertItemHandler_Call {
+func (_c *mockFeedbagHandler_InsertItemHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error)) *mockFeedbagHandler_InsertItemHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // QueryHandler provides a mock function with given fields: ctx, sess
-func (_m *MockFeedbagHandler) QueryHandler(ctx context.Context, sess *state.Session) (oscar.XMessage, error) {
+func (_m *mockFeedbagHandler) QueryHandler(ctx context.Context, sess *state.Session) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess)
 
 	var r0 oscar.XMessage
@@ -156,37 +156,37 @@ func (_m *MockFeedbagHandler) QueryHandler(ctx context.Context, sess *state.Sess
 	return r0, r1
 }
 
-// MockFeedbagHandler_QueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryHandler'
-type MockFeedbagHandler_QueryHandler_Call struct {
+// mockFeedbagHandler_QueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryHandler'
+type mockFeedbagHandler_QueryHandler_Call struct {
 	*mock.Call
 }
 
 // QueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - sess *state.Session
-func (_e *MockFeedbagHandler_Expecter) QueryHandler(ctx interface{}, sess interface{}) *MockFeedbagHandler_QueryHandler_Call {
-	return &MockFeedbagHandler_QueryHandler_Call{Call: _e.mock.On("QueryHandler", ctx, sess)}
+func (_e *mockFeedbagHandler_Expecter) QueryHandler(ctx interface{}, sess interface{}) *mockFeedbagHandler_QueryHandler_Call {
+	return &mockFeedbagHandler_QueryHandler_Call{Call: _e.mock.On("QueryHandler", ctx, sess)}
 }
 
-func (_c *MockFeedbagHandler_QueryHandler_Call) Run(run func(ctx context.Context, sess *state.Session)) *MockFeedbagHandler_QueryHandler_Call {
+func (_c *mockFeedbagHandler_QueryHandler_Call) Run(run func(ctx context.Context, sess *state.Session)) *mockFeedbagHandler_QueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagHandler_QueryHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockFeedbagHandler_QueryHandler_Call {
+func (_c *mockFeedbagHandler_QueryHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockFeedbagHandler_QueryHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagHandler_QueryHandler_Call) RunAndReturn(run func(context.Context, *state.Session) (oscar.XMessage, error)) *MockFeedbagHandler_QueryHandler_Call {
+func (_c *mockFeedbagHandler_QueryHandler_Call) RunAndReturn(run func(context.Context, *state.Session) (oscar.XMessage, error)) *mockFeedbagHandler_QueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // QueryIfModifiedHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockFeedbagHandler) QueryIfModifiedHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error) {
+func (_m *mockFeedbagHandler) QueryIfModifiedHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -209,8 +209,8 @@ func (_m *MockFeedbagHandler) QueryIfModifiedHandler(ctx context.Context, sess *
 	return r0, r1
 }
 
-// MockFeedbagHandler_QueryIfModifiedHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryIfModifiedHandler'
-type MockFeedbagHandler_QueryIfModifiedHandler_Call struct {
+// mockFeedbagHandler_QueryIfModifiedHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryIfModifiedHandler'
+type mockFeedbagHandler_QueryIfModifiedHandler_Call struct {
 	*mock.Call
 }
 
@@ -218,29 +218,29 @@ type MockFeedbagHandler_QueryIfModifiedHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified
-func (_e *MockFeedbagHandler_Expecter) QueryIfModifiedHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockFeedbagHandler_QueryIfModifiedHandler_Call {
-	return &MockFeedbagHandler_QueryIfModifiedHandler_Call{Call: _e.mock.On("QueryIfModifiedHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockFeedbagHandler_Expecter) QueryIfModifiedHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockFeedbagHandler_QueryIfModifiedHandler_Call {
+	return &mockFeedbagHandler_QueryIfModifiedHandler_Call{Call: _e.mock.On("QueryIfModifiedHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockFeedbagHandler_QueryIfModifiedHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified)) *MockFeedbagHandler_QueryIfModifiedHandler_Call {
+func (_c *mockFeedbagHandler_QueryIfModifiedHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified)) *mockFeedbagHandler_QueryIfModifiedHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x13_0x05_FeedbagQueryIfModified))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagHandler_QueryIfModifiedHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockFeedbagHandler_QueryIfModifiedHandler_Call {
+func (_c *mockFeedbagHandler_QueryIfModifiedHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockFeedbagHandler_QueryIfModifiedHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagHandler_QueryIfModifiedHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error)) *MockFeedbagHandler_QueryIfModifiedHandler_Call {
+func (_c *mockFeedbagHandler_QueryIfModifiedHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error)) *mockFeedbagHandler_QueryIfModifiedHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RightsQueryHandler provides a mock function with given fields: _a0
-func (_m *MockFeedbagHandler) RightsQueryHandler(_a0 context.Context) oscar.XMessage {
+func (_m *mockFeedbagHandler) RightsQueryHandler(_a0 context.Context) oscar.XMessage {
 	ret := _m.Called(_a0)
 
 	var r0 oscar.XMessage
@@ -253,70 +253,70 @@ func (_m *MockFeedbagHandler) RightsQueryHandler(_a0 context.Context) oscar.XMes
 	return r0
 }
 
-// MockFeedbagHandler_RightsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RightsQueryHandler'
-type MockFeedbagHandler_RightsQueryHandler_Call struct {
+// mockFeedbagHandler_RightsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RightsQueryHandler'
+type mockFeedbagHandler_RightsQueryHandler_Call struct {
 	*mock.Call
 }
 
 // RightsQueryHandler is a helper method to define mock.On call
 //   - _a0 context.Context
-func (_e *MockFeedbagHandler_Expecter) RightsQueryHandler(_a0 interface{}) *MockFeedbagHandler_RightsQueryHandler_Call {
-	return &MockFeedbagHandler_RightsQueryHandler_Call{Call: _e.mock.On("RightsQueryHandler", _a0)}
+func (_e *mockFeedbagHandler_Expecter) RightsQueryHandler(_a0 interface{}) *mockFeedbagHandler_RightsQueryHandler_Call {
+	return &mockFeedbagHandler_RightsQueryHandler_Call{Call: _e.mock.On("RightsQueryHandler", _a0)}
 }
 
-func (_c *MockFeedbagHandler_RightsQueryHandler_Call) Run(run func(_a0 context.Context)) *MockFeedbagHandler_RightsQueryHandler_Call {
+func (_c *mockFeedbagHandler_RightsQueryHandler_Call) Run(run func(_a0 context.Context)) *mockFeedbagHandler_RightsQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagHandler_RightsQueryHandler_Call) Return(_a0 oscar.XMessage) *MockFeedbagHandler_RightsQueryHandler_Call {
+func (_c *mockFeedbagHandler_RightsQueryHandler_Call) Return(_a0 oscar.XMessage) *mockFeedbagHandler_RightsQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockFeedbagHandler_RightsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockFeedbagHandler_RightsQueryHandler_Call {
+func (_c *mockFeedbagHandler_RightsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockFeedbagHandler_RightsQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // StartClusterHandler provides a mock function with given fields: _a0, _a1
-func (_m *MockFeedbagHandler) StartClusterHandler(_a0 context.Context, _a1 oscar.SNAC_0x13_0x11_FeedbagStartCluster) {
+func (_m *mockFeedbagHandler) StartClusterHandler(_a0 context.Context, _a1 oscar.SNAC_0x13_0x11_FeedbagStartCluster) {
 	_m.Called(_a0, _a1)
 }
 
-// MockFeedbagHandler_StartClusterHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartClusterHandler'
-type MockFeedbagHandler_StartClusterHandler_Call struct {
+// mockFeedbagHandler_StartClusterHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartClusterHandler'
+type mockFeedbagHandler_StartClusterHandler_Call struct {
 	*mock.Call
 }
 
 // StartClusterHandler is a helper method to define mock.On call
 //   - _a0 context.Context
 //   - _a1 oscar.SNAC_0x13_0x11_FeedbagStartCluster
-func (_e *MockFeedbagHandler_Expecter) StartClusterHandler(_a0 interface{}, _a1 interface{}) *MockFeedbagHandler_StartClusterHandler_Call {
-	return &MockFeedbagHandler_StartClusterHandler_Call{Call: _e.mock.On("StartClusterHandler", _a0, _a1)}
+func (_e *mockFeedbagHandler_Expecter) StartClusterHandler(_a0 interface{}, _a1 interface{}) *mockFeedbagHandler_StartClusterHandler_Call {
+	return &mockFeedbagHandler_StartClusterHandler_Call{Call: _e.mock.On("StartClusterHandler", _a0, _a1)}
 }
 
-func (_c *MockFeedbagHandler_StartClusterHandler_Call) Run(run func(_a0 context.Context, _a1 oscar.SNAC_0x13_0x11_FeedbagStartCluster)) *MockFeedbagHandler_StartClusterHandler_Call {
+func (_c *mockFeedbagHandler_StartClusterHandler_Call) Run(run func(_a0 context.Context, _a1 oscar.SNAC_0x13_0x11_FeedbagStartCluster)) *mockFeedbagHandler_StartClusterHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x13_0x11_FeedbagStartCluster))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagHandler_StartClusterHandler_Call) Return() *MockFeedbagHandler_StartClusterHandler_Call {
+func (_c *mockFeedbagHandler_StartClusterHandler_Call) Return() *mockFeedbagHandler_StartClusterHandler_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockFeedbagHandler_StartClusterHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x13_0x11_FeedbagStartCluster)) *MockFeedbagHandler_StartClusterHandler_Call {
+func (_c *mockFeedbagHandler_StartClusterHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x13_0x11_FeedbagStartCluster)) *mockFeedbagHandler_StartClusterHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // UpdateItemHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockFeedbagHandler) UpdateItemHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error) {
+func (_m *mockFeedbagHandler) UpdateItemHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -339,8 +339,8 @@ func (_m *MockFeedbagHandler) UpdateItemHandler(ctx context.Context, sess *state
 	return r0, r1
 }
 
-// MockFeedbagHandler_UpdateItemHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateItemHandler'
-type MockFeedbagHandler_UpdateItemHandler_Call struct {
+// mockFeedbagHandler_UpdateItemHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateItemHandler'
+type mockFeedbagHandler_UpdateItemHandler_Call struct {
 	*mock.Call
 }
 
@@ -348,34 +348,34 @@ type MockFeedbagHandler_UpdateItemHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem
-func (_e *MockFeedbagHandler_Expecter) UpdateItemHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockFeedbagHandler_UpdateItemHandler_Call {
-	return &MockFeedbagHandler_UpdateItemHandler_Call{Call: _e.mock.On("UpdateItemHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockFeedbagHandler_Expecter) UpdateItemHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockFeedbagHandler_UpdateItemHandler_Call {
+	return &mockFeedbagHandler_UpdateItemHandler_Call{Call: _e.mock.On("UpdateItemHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockFeedbagHandler_UpdateItemHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem)) *MockFeedbagHandler_UpdateItemHandler_Call {
+func (_c *mockFeedbagHandler_UpdateItemHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem)) *mockFeedbagHandler_UpdateItemHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x13_0x09_FeedbagUpdateItem))
 	})
 	return _c
 }
 
-func (_c *MockFeedbagHandler_UpdateItemHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockFeedbagHandler_UpdateItemHandler_Call {
+func (_c *mockFeedbagHandler_UpdateItemHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockFeedbagHandler_UpdateItemHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagHandler_UpdateItemHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error)) *MockFeedbagHandler_UpdateItemHandler_Call {
+func (_c *mockFeedbagHandler_UpdateItemHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error)) *mockFeedbagHandler_UpdateItemHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockFeedbagHandler creates a new instance of MockFeedbagHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockFeedbagHandler creates a new instance of mockFeedbagHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockFeedbagHandler(t interface {
+func newMockFeedbagHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockFeedbagHandler {
-	mock := &MockFeedbagHandler{}
+}) *mockFeedbagHandler {
+	mock := &mockFeedbagHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/feedbag_test.go

@@ -238,7 +238,7 @@ func TestFeedbagRouter_RouteFeedbag(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svc := NewMockFeedbagHandler(t)
+			svc := newMockFeedbagHandler(t)
 			svc.EXPECT().
 				DeleteItemHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
 				Return(tc.output, tc.handlerErr).

server/icbm.go

@@ -46,10 +46,13 @@ func (rt *ICBMRouter) RouteICBM(ctx context.Context, sess *state.Session, SNACFr
 			return err
 		}
 		outSNAC, err := rt.ChannelMsgToHostHandler(ctx, sess, inSNAC)
-		if err != nil || outSNAC == nil {
+		if err != nil {
 			return err
 		}
 		rt.Logger.InfoContext(ctx, "user sent an IM", slog.String("recipient", inSNAC.ScreenName))
+		if outSNAC == nil {
+			return nil
+		}
 		rt.logRequestAndResponse(ctx, SNACFrame, inSNAC, outSNAC.SnacFrame, outSNAC.SnacOut)
 		return writeOutSNAC(SNACFrame, outSNAC.SnacFrame, outSNAC.SnacOut, sequence, w)
 	case oscar.ICBMEvilRequest:

server/icbm_mock.go

@@ -11,21 +11,21 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockICBMHandler is an autogenerated mock type for the ICBMHandler type
-type MockICBMHandler struct {
+// mockICBMHandler is an autogenerated mock type for the ICBMHandler type
+type mockICBMHandler struct {
 	mock.Mock
 }
 
-type MockICBMHandler_Expecter struct {
+type mockICBMHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockICBMHandler) EXPECT() *MockICBMHandler_Expecter {
-	return &MockICBMHandler_Expecter{mock: &_m.Mock}
+func (_m *mockICBMHandler) EXPECT() *mockICBMHandler_Expecter {
+	return &mockICBMHandler_Expecter{mock: &_m.Mock}
 }
 
 // ChannelMsgToHostHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockICBMHandler) ChannelMsgToHostHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error) {
+func (_m *mockICBMHandler) ChannelMsgToHostHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 *oscar.XMessage
@@ -50,8 +50,8 @@ func (_m *MockICBMHandler) ChannelMsgToHostHandler(ctx context.Context, sess *st
 	return r0, r1
 }
 
-// MockICBMHandler_ChannelMsgToHostHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelMsgToHostHandler'
-type MockICBMHandler_ChannelMsgToHostHandler_Call struct {
+// mockICBMHandler_ChannelMsgToHostHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChannelMsgToHostHandler'
+type mockICBMHandler_ChannelMsgToHostHandler_Call struct {
 	*mock.Call
 }
 
@@ -59,29 +59,29 @@ type MockICBMHandler_ChannelMsgToHostHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost
-func (_e *MockICBMHandler_Expecter) ChannelMsgToHostHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockICBMHandler_ChannelMsgToHostHandler_Call {
-	return &MockICBMHandler_ChannelMsgToHostHandler_Call{Call: _e.mock.On("ChannelMsgToHostHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockICBMHandler_Expecter) ChannelMsgToHostHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockICBMHandler_ChannelMsgToHostHandler_Call {
+	return &mockICBMHandler_ChannelMsgToHostHandler_Call{Call: _e.mock.On("ChannelMsgToHostHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockICBMHandler_ChannelMsgToHostHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost)) *MockICBMHandler_ChannelMsgToHostHandler_Call {
+func (_c *mockICBMHandler_ChannelMsgToHostHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost)) *mockICBMHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost))
 	})
 	return _c
 }
 
-func (_c *MockICBMHandler_ChannelMsgToHostHandler_Call) Return(_a0 *oscar.XMessage, _a1 error) *MockICBMHandler_ChannelMsgToHostHandler_Call {
+func (_c *mockICBMHandler_ChannelMsgToHostHandler_Call) Return(_a0 *oscar.XMessage, _a1 error) *mockICBMHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockICBMHandler_ChannelMsgToHostHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error)) *MockICBMHandler_ChannelMsgToHostHandler_Call {
+func (_c *mockICBMHandler_ChannelMsgToHostHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error)) *mockICBMHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // ClientEventHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockICBMHandler) ClientEventHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error {
+func (_m *mockICBMHandler) ClientEventHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
@@ -94,8 +94,8 @@ func (_m *MockICBMHandler) ClientEventHandler(ctx context.Context, sess *state.S
 	return r0
 }
 
-// MockICBMHandler_ClientEventHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientEventHandler'
-type MockICBMHandler_ClientEventHandler_Call struct {
+// mockICBMHandler_ClientEventHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientEventHandler'
+type mockICBMHandler_ClientEventHandler_Call struct {
 	*mock.Call
 }
 
@@ -103,29 +103,29 @@ type MockICBMHandler_ClientEventHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent
-func (_e *MockICBMHandler_Expecter) ClientEventHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockICBMHandler_ClientEventHandler_Call {
-	return &MockICBMHandler_ClientEventHandler_Call{Call: _e.mock.On("ClientEventHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockICBMHandler_Expecter) ClientEventHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockICBMHandler_ClientEventHandler_Call {
+	return &mockICBMHandler_ClientEventHandler_Call{Call: _e.mock.On("ClientEventHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockICBMHandler_ClientEventHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent)) *MockICBMHandler_ClientEventHandler_Call {
+func (_c *mockICBMHandler_ClientEventHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent)) *mockICBMHandler_ClientEventHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x04_0x14_ICBMClientEvent))
 	})
 	return _c
 }
 
-func (_c *MockICBMHandler_ClientEventHandler_Call) Return(_a0 error) *MockICBMHandler_ClientEventHandler_Call {
+func (_c *mockICBMHandler_ClientEventHandler_Call) Return(_a0 error) *mockICBMHandler_ClientEventHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockICBMHandler_ClientEventHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x04_0x14_ICBMClientEvent) error) *MockICBMHandler_ClientEventHandler_Call {
+func (_c *mockICBMHandler_ClientEventHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x04_0x14_ICBMClientEvent) error) *mockICBMHandler_ClientEventHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // EvilRequestHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockICBMHandler) EvilRequestHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error) {
+func (_m *mockICBMHandler) EvilRequestHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -148,8 +148,8 @@ func (_m *MockICBMHandler) EvilRequestHandler(ctx context.Context, sess *state.S
 	return r0, r1
 }
 
-// MockICBMHandler_EvilRequestHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EvilRequestHandler'
-type MockICBMHandler_EvilRequestHandler_Call struct {
+// mockICBMHandler_EvilRequestHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EvilRequestHandler'
+type mockICBMHandler_EvilRequestHandler_Call struct {
 	*mock.Call
 }
 
@@ -157,29 +157,29 @@ type MockICBMHandler_EvilRequestHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest
-func (_e *MockICBMHandler_Expecter) EvilRequestHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockICBMHandler_EvilRequestHandler_Call {
-	return &MockICBMHandler_EvilRequestHandler_Call{Call: _e.mock.On("EvilRequestHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockICBMHandler_Expecter) EvilRequestHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockICBMHandler_EvilRequestHandler_Call {
+	return &mockICBMHandler_EvilRequestHandler_Call{Call: _e.mock.On("EvilRequestHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockICBMHandler_EvilRequestHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest)) *MockICBMHandler_EvilRequestHandler_Call {
+func (_c *mockICBMHandler_EvilRequestHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest)) *mockICBMHandler_EvilRequestHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x04_0x08_ICBMEvilRequest))
 	})
 	return _c
 }
 
-func (_c *MockICBMHandler_EvilRequestHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockICBMHandler_EvilRequestHandler_Call {
+func (_c *mockICBMHandler_EvilRequestHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockICBMHandler_EvilRequestHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockICBMHandler_EvilRequestHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error)) *MockICBMHandler_EvilRequestHandler_Call {
+func (_c *mockICBMHandler_EvilRequestHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error)) *mockICBMHandler_EvilRequestHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // ParameterQueryHandler provides a mock function with given fields: _a0
-func (_m *MockICBMHandler) ParameterQueryHandler(_a0 context.Context) oscar.XMessage {
+func (_m *mockICBMHandler) ParameterQueryHandler(_a0 context.Context) oscar.XMessage {
 	ret := _m.Called(_a0)
 
 	var r0 oscar.XMessage
@@ -192,41 +192,41 @@ func (_m *MockICBMHandler) ParameterQueryHandler(_a0 context.Context) oscar.XMes
 	return r0
 }
 
-// MockICBMHandler_ParameterQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ParameterQueryHandler'
-type MockICBMHandler_ParameterQueryHandler_Call struct {
+// mockICBMHandler_ParameterQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ParameterQueryHandler'
+type mockICBMHandler_ParameterQueryHandler_Call struct {
 	*mock.Call
 }
 
 // ParameterQueryHandler is a helper method to define mock.On call
 //   - _a0 context.Context
-func (_e *MockICBMHandler_Expecter) ParameterQueryHandler(_a0 interface{}) *MockICBMHandler_ParameterQueryHandler_Call {
-	return &MockICBMHandler_ParameterQueryHandler_Call{Call: _e.mock.On("ParameterQueryHandler", _a0)}
+func (_e *mockICBMHandler_Expecter) ParameterQueryHandler(_a0 interface{}) *mockICBMHandler_ParameterQueryHandler_Call {
+	return &mockICBMHandler_ParameterQueryHandler_Call{Call: _e.mock.On("ParameterQueryHandler", _a0)}
 }
 
-func (_c *MockICBMHandler_ParameterQueryHandler_Call) Run(run func(_a0 context.Context)) *MockICBMHandler_ParameterQueryHandler_Call {
+func (_c *mockICBMHandler_ParameterQueryHandler_Call) Run(run func(_a0 context.Context)) *mockICBMHandler_ParameterQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockICBMHandler_ParameterQueryHandler_Call) Return(_a0 oscar.XMessage) *MockICBMHandler_ParameterQueryHandler_Call {
+func (_c *mockICBMHandler_ParameterQueryHandler_Call) Return(_a0 oscar.XMessage) *mockICBMHandler_ParameterQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockICBMHandler_ParameterQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockICBMHandler_ParameterQueryHandler_Call {
+func (_c *mockICBMHandler_ParameterQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockICBMHandler_ParameterQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockICBMHandler creates a new instance of MockICBMHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockICBMHandler creates a new instance of mockICBMHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockICBMHandler(t interface {
+func newMockICBMHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockICBMHandler {
-	mock := &MockICBMHandler{}
+}) *mockICBMHandler {
+	mock := &mockICBMHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/icbm_test.go

@@ -151,7 +151,7 @@ func TestICBMRouter_RouteICBM(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svc := NewMockICBMHandler(t)
+			svc := newMockICBMHandler(t)
 			svc.EXPECT().
 				ChannelMsgToHostHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
 				Return(tc.output, tc.handlerErr).

server/locate_mock.go

@@ -11,21 +11,21 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockLocateHandler is an autogenerated mock type for the LocateHandler type
-type MockLocateHandler struct {
+// mockLocateHandler is an autogenerated mock type for the LocateHandler type
+type mockLocateHandler struct {
 	mock.Mock
 }
 
-type MockLocateHandler_Expecter struct {
+type mockLocateHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockLocateHandler) EXPECT() *MockLocateHandler_Expecter {
-	return &MockLocateHandler_Expecter{mock: &_m.Mock}
+func (_m *mockLocateHandler) EXPECT() *mockLocateHandler_Expecter {
+	return &mockLocateHandler_Expecter{mock: &_m.Mock}
 }
 
 // RightsQueryHandler provides a mock function with given fields: ctx
-func (_m *MockLocateHandler) RightsQueryHandler(ctx context.Context) oscar.XMessage {
+func (_m *mockLocateHandler) RightsQueryHandler(ctx context.Context) oscar.XMessage {
 	ret := _m.Called(ctx)
 
 	var r0 oscar.XMessage
@@ -38,36 +38,36 @@ func (_m *MockLocateHandler) RightsQueryHandler(ctx context.Context) oscar.XMess
 	return r0
 }
 
-// MockLocateHandler_RightsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RightsQueryHandler'
-type MockLocateHandler_RightsQueryHandler_Call struct {
+// mockLocateHandler_RightsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RightsQueryHandler'
+type mockLocateHandler_RightsQueryHandler_Call struct {
 	*mock.Call
 }
 
 // RightsQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-func (_e *MockLocateHandler_Expecter) RightsQueryHandler(ctx interface{}) *MockLocateHandler_RightsQueryHandler_Call {
-	return &MockLocateHandler_RightsQueryHandler_Call{Call: _e.mock.On("RightsQueryHandler", ctx)}
+func (_e *mockLocateHandler_Expecter) RightsQueryHandler(ctx interface{}) *mockLocateHandler_RightsQueryHandler_Call {
+	return &mockLocateHandler_RightsQueryHandler_Call{Call: _e.mock.On("RightsQueryHandler", ctx)}
 }
 
-func (_c *MockLocateHandler_RightsQueryHandler_Call) Run(run func(ctx context.Context)) *MockLocateHandler_RightsQueryHandler_Call {
+func (_c *mockLocateHandler_RightsQueryHandler_Call) Run(run func(ctx context.Context)) *mockLocateHandler_RightsQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockLocateHandler_RightsQueryHandler_Call) Return(_a0 oscar.XMessage) *MockLocateHandler_RightsQueryHandler_Call {
+func (_c *mockLocateHandler_RightsQueryHandler_Call) Return(_a0 oscar.XMessage) *mockLocateHandler_RightsQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockLocateHandler_RightsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockLocateHandler_RightsQueryHandler_Call {
+func (_c *mockLocateHandler_RightsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockLocateHandler_RightsQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // SetDirInfoHandler provides a mock function with given fields: ctx
-func (_m *MockLocateHandler) SetDirInfoHandler(ctx context.Context) oscar.XMessage {
+func (_m *mockLocateHandler) SetDirInfoHandler(ctx context.Context) oscar.XMessage {
 	ret := _m.Called(ctx)
 
 	var r0 oscar.XMessage
@@ -80,36 +80,36 @@ func (_m *MockLocateHandler) SetDirInfoHandler(ctx context.Context) oscar.XMessa
 	return r0
 }
 
-// MockLocateHandler_SetDirInfoHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDirInfoHandler'
-type MockLocateHandler_SetDirInfoHandler_Call struct {
+// mockLocateHandler_SetDirInfoHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDirInfoHandler'
+type mockLocateHandler_SetDirInfoHandler_Call struct {
 	*mock.Call
 }
 
 // SetDirInfoHandler is a helper method to define mock.On call
 //   - ctx context.Context
-func (_e *MockLocateHandler_Expecter) SetDirInfoHandler(ctx interface{}) *MockLocateHandler_SetDirInfoHandler_Call {
-	return &MockLocateHandler_SetDirInfoHandler_Call{Call: _e.mock.On("SetDirInfoHandler", ctx)}
+func (_e *mockLocateHandler_Expecter) SetDirInfoHandler(ctx interface{}) *mockLocateHandler_SetDirInfoHandler_Call {
+	return &mockLocateHandler_SetDirInfoHandler_Call{Call: _e.mock.On("SetDirInfoHandler", ctx)}
 }
 
-func (_c *MockLocateHandler_SetDirInfoHandler_Call) Run(run func(ctx context.Context)) *MockLocateHandler_SetDirInfoHandler_Call {
+func (_c *mockLocateHandler_SetDirInfoHandler_Call) Run(run func(ctx context.Context)) *mockLocateHandler_SetDirInfoHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockLocateHandler_SetDirInfoHandler_Call) Return(_a0 oscar.XMessage) *MockLocateHandler_SetDirInfoHandler_Call {
+func (_c *mockLocateHandler_SetDirInfoHandler_Call) Return(_a0 oscar.XMessage) *mockLocateHandler_SetDirInfoHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockLocateHandler_SetDirInfoHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockLocateHandler_SetDirInfoHandler_Call {
+func (_c *mockLocateHandler_SetDirInfoHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockLocateHandler_SetDirInfoHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // SetInfoHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockLocateHandler) SetInfoHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo) error {
+func (_m *mockLocateHandler) SetInfoHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
@@ -122,8 +122,8 @@ func (_m *MockLocateHandler) SetInfoHandler(ctx context.Context, sess *state.Ses
 	return r0
 }
 
-// MockLocateHandler_SetInfoHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetInfoHandler'
-type MockLocateHandler_SetInfoHandler_Call struct {
+// mockLocateHandler_SetInfoHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetInfoHandler'
+type mockLocateHandler_SetInfoHandler_Call struct {
 	*mock.Call
 }
 
@@ -131,29 +131,29 @@ type MockLocateHandler_SetInfoHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo
-func (_e *MockLocateHandler_Expecter) SetInfoHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockLocateHandler_SetInfoHandler_Call {
-	return &MockLocateHandler_SetInfoHandler_Call{Call: _e.mock.On("SetInfoHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockLocateHandler_Expecter) SetInfoHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockLocateHandler_SetInfoHandler_Call {
+	return &mockLocateHandler_SetInfoHandler_Call{Call: _e.mock.On("SetInfoHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockLocateHandler_SetInfoHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo)) *MockLocateHandler_SetInfoHandler_Call {
+func (_c *mockLocateHandler_SetInfoHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo)) *mockLocateHandler_SetInfoHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x02_0x04_LocateSetInfo))
 	})
 	return _c
 }
 
-func (_c *MockLocateHandler_SetInfoHandler_Call) Return(_a0 error) *MockLocateHandler_SetInfoHandler_Call {
+func (_c *mockLocateHandler_SetInfoHandler_Call) Return(_a0 error) *mockLocateHandler_SetInfoHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockLocateHandler_SetInfoHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x02_0x04_LocateSetInfo) error) *MockLocateHandler_SetInfoHandler_Call {
+func (_c *mockLocateHandler_SetInfoHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x02_0x04_LocateSetInfo) error) *mockLocateHandler_SetInfoHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // SetKeywordInfoHandler provides a mock function with given fields: ctx
-func (_m *MockLocateHandler) SetKeywordInfoHandler(ctx context.Context) oscar.XMessage {
+func (_m *mockLocateHandler) SetKeywordInfoHandler(ctx context.Context) oscar.XMessage {
 	ret := _m.Called(ctx)
 
 	var r0 oscar.XMessage
@@ -166,36 +166,36 @@ func (_m *MockLocateHandler) SetKeywordInfoHandler(ctx context.Context) oscar.XM
 	return r0
 }
 
-// MockLocateHandler_SetKeywordInfoHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKeywordInfoHandler'
-type MockLocateHandler_SetKeywordInfoHandler_Call struct {
+// mockLocateHandler_SetKeywordInfoHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetKeywordInfoHandler'
+type mockLocateHandler_SetKeywordInfoHandler_Call struct {
 	*mock.Call
 }
 
 // SetKeywordInfoHandler is a helper method to define mock.On call
 //   - ctx context.Context
-func (_e *MockLocateHandler_Expecter) SetKeywordInfoHandler(ctx interface{}) *MockLocateHandler_SetKeywordInfoHandler_Call {
-	return &MockLocateHandler_SetKeywordInfoHandler_Call{Call: _e.mock.On("SetKeywordInfoHandler", ctx)}
+func (_e *mockLocateHandler_Expecter) SetKeywordInfoHandler(ctx interface{}) *mockLocateHandler_SetKeywordInfoHandler_Call {
+	return &mockLocateHandler_SetKeywordInfoHandler_Call{Call: _e.mock.On("SetKeywordInfoHandler", ctx)}
 }
 
-func (_c *MockLocateHandler_SetKeywordInfoHandler_Call) Run(run func(ctx context.Context)) *MockLocateHandler_SetKeywordInfoHandler_Call {
+func (_c *mockLocateHandler_SetKeywordInfoHandler_Call) Run(run func(ctx context.Context)) *mockLocateHandler_SetKeywordInfoHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockLocateHandler_SetKeywordInfoHandler_Call) Return(_a0 oscar.XMessage) *MockLocateHandler_SetKeywordInfoHandler_Call {
+func (_c *mockLocateHandler_SetKeywordInfoHandler_Call) Return(_a0 oscar.XMessage) *mockLocateHandler_SetKeywordInfoHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockLocateHandler_SetKeywordInfoHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockLocateHandler_SetKeywordInfoHandler_Call {
+func (_c *mockLocateHandler_SetKeywordInfoHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockLocateHandler_SetKeywordInfoHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // UserInfoQuery2Handler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockLocateHandler) UserInfoQuery2Handler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error) {
+func (_m *mockLocateHandler) UserInfoQuery2Handler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -218,8 +218,8 @@ func (_m *MockLocateHandler) UserInfoQuery2Handler(ctx context.Context, sess *st
 	return r0, r1
 }
 
-// MockLocateHandler_UserInfoQuery2Handler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserInfoQuery2Handler'
-type MockLocateHandler_UserInfoQuery2Handler_Call struct {
+// mockLocateHandler_UserInfoQuery2Handler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserInfoQuery2Handler'
+type mockLocateHandler_UserInfoQuery2Handler_Call struct {
 	*mock.Call
 }
 
@@ -227,34 +227,34 @@ type MockLocateHandler_UserInfoQuery2Handler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2
-func (_e *MockLocateHandler_Expecter) UserInfoQuery2Handler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockLocateHandler_UserInfoQuery2Handler_Call {
-	return &MockLocateHandler_UserInfoQuery2Handler_Call{Call: _e.mock.On("UserInfoQuery2Handler", ctx, sess, snacPayloadIn)}
+func (_e *mockLocateHandler_Expecter) UserInfoQuery2Handler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockLocateHandler_UserInfoQuery2Handler_Call {
+	return &mockLocateHandler_UserInfoQuery2Handler_Call{Call: _e.mock.On("UserInfoQuery2Handler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockLocateHandler_UserInfoQuery2Handler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2)) *MockLocateHandler_UserInfoQuery2Handler_Call {
+func (_c *mockLocateHandler_UserInfoQuery2Handler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2)) *mockLocateHandler_UserInfoQuery2Handler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x02_0x15_LocateUserInfoQuery2))
 	})
 	return _c
 }
 
-func (_c *MockLocateHandler_UserInfoQuery2Handler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockLocateHandler_UserInfoQuery2Handler_Call {
+func (_c *mockLocateHandler_UserInfoQuery2Handler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockLocateHandler_UserInfoQuery2Handler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockLocateHandler_UserInfoQuery2Handler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error)) *MockLocateHandler_UserInfoQuery2Handler_Call {
+func (_c *mockLocateHandler_UserInfoQuery2Handler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error)) *mockLocateHandler_UserInfoQuery2Handler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockLocateHandler creates a new instance of MockLocateHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockLocateHandler creates a new instance of mockLocateHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockLocateHandler(t interface {
+func newMockLocateHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockLocateHandler {
-	mock := &MockLocateHandler{}
+}) *mockLocateHandler {
+	mock := &mockLocateHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/locate_test.go

@@ -184,7 +184,7 @@ func TestLocateRouter_RouteLocate(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svc := NewMockLocateHandler(t)
+			svc := newMockLocateHandler(t)
 			svc.EXPECT().
 				RightsQueryHandler(mock.Anything).
 				Return(tc.output).

server/oservice_bos_mock.go

@@ -11,21 +11,21 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockOServiceBOSHandler is an autogenerated mock type for the OServiceBOSHandler type
-type MockOServiceBOSHandler struct {
+// mockOServiceBOSHandler is an autogenerated mock type for the OServiceBOSHandler type
+type mockOServiceBOSHandler struct {
 	mock.Mock
 }
 
-type MockOServiceBOSHandler_Expecter struct {
+type mockOServiceBOSHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockOServiceBOSHandler) EXPECT() *MockOServiceBOSHandler_Expecter {
-	return &MockOServiceBOSHandler_Expecter{mock: &_m.Mock}
+func (_m *mockOServiceBOSHandler) EXPECT() *mockOServiceBOSHandler_Expecter {
+	return &mockOServiceBOSHandler_Expecter{mock: &_m.Mock}
 }
 
 // ClientOnlineHandler provides a mock function with given fields: ctx, snacPayloadIn, sess
-func (_m *MockOServiceBOSHandler) ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *state.Session) error {
+func (_m *mockOServiceBOSHandler) ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *state.Session) error {
 	ret := _m.Called(ctx, snacPayloadIn, sess)
 
 	var r0 error
@@ -38,8 +38,8 @@ func (_m *MockOServiceBOSHandler) ClientOnlineHandler(ctx context.Context, snacP
 	return r0
 }
 
-// MockOServiceBOSHandler_ClientOnlineHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientOnlineHandler'
-type MockOServiceBOSHandler_ClientOnlineHandler_Call struct {
+// mockOServiceBOSHandler_ClientOnlineHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientOnlineHandler'
+type mockOServiceBOSHandler_ClientOnlineHandler_Call struct {
 	*mock.Call
 }
 
@@ -47,29 +47,29 @@ type MockOServiceBOSHandler_ClientOnlineHandler_Call struct {
 //   - ctx context.Context
 //   - snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline
 //   - sess *state.Session
-func (_e *MockOServiceBOSHandler_Expecter) ClientOnlineHandler(ctx interface{}, snacPayloadIn interface{}, sess interface{}) *MockOServiceBOSHandler_ClientOnlineHandler_Call {
-	return &MockOServiceBOSHandler_ClientOnlineHandler_Call{Call: _e.mock.On("ClientOnlineHandler", ctx, snacPayloadIn, sess)}
+func (_e *mockOServiceBOSHandler_Expecter) ClientOnlineHandler(ctx interface{}, snacPayloadIn interface{}, sess interface{}) *mockOServiceBOSHandler_ClientOnlineHandler_Call {
+	return &mockOServiceBOSHandler_ClientOnlineHandler_Call{Call: _e.mock.On("ClientOnlineHandler", ctx, snacPayloadIn, sess)}
 }
 
-func (_c *MockOServiceBOSHandler_ClientOnlineHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *state.Session)) *MockOServiceBOSHandler_ClientOnlineHandler_Call {
+func (_c *mockOServiceBOSHandler_ClientOnlineHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *state.Session)) *mockOServiceBOSHandler_ClientOnlineHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x02_OServiceClientOnline), args[2].(*state.Session))
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_ClientOnlineHandler_Call) Return(_a0 error) *MockOServiceBOSHandler_ClientOnlineHandler_Call {
+func (_c *mockOServiceBOSHandler_ClientOnlineHandler_Call) Return(_a0 error) *mockOServiceBOSHandler_ClientOnlineHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_ClientOnlineHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *state.Session) error) *MockOServiceBOSHandler_ClientOnlineHandler_Call {
+func (_c *mockOServiceBOSHandler_ClientOnlineHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *state.Session) error) *mockOServiceBOSHandler_ClientOnlineHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // ClientVersionsHandler provides a mock function with given fields: ctx, snacPayloadIn
-func (_m *MockOServiceBOSHandler) ClientVersionsHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage {
+func (_m *mockOServiceBOSHandler) ClientVersionsHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage {
 	ret := _m.Called(ctx, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -82,37 +82,37 @@ func (_m *MockOServiceBOSHandler) ClientVersionsHandler(ctx context.Context, sna
 	return r0
 }
 
-// MockOServiceBOSHandler_ClientVersionsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientVersionsHandler'
-type MockOServiceBOSHandler_ClientVersionsHandler_Call struct {
+// mockOServiceBOSHandler_ClientVersionsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientVersionsHandler'
+type mockOServiceBOSHandler_ClientVersionsHandler_Call struct {
 	*mock.Call
 }
 
 // ClientVersionsHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions
-func (_e *MockOServiceBOSHandler_Expecter) ClientVersionsHandler(ctx interface{}, snacPayloadIn interface{}) *MockOServiceBOSHandler_ClientVersionsHandler_Call {
-	return &MockOServiceBOSHandler_ClientVersionsHandler_Call{Call: _e.mock.On("ClientVersionsHandler", ctx, snacPayloadIn)}
+func (_e *mockOServiceBOSHandler_Expecter) ClientVersionsHandler(ctx interface{}, snacPayloadIn interface{}) *mockOServiceBOSHandler_ClientVersionsHandler_Call {
+	return &mockOServiceBOSHandler_ClientVersionsHandler_Call{Call: _e.mock.On("ClientVersionsHandler", ctx, snacPayloadIn)}
 }
 
-func (_c *MockOServiceBOSHandler_ClientVersionsHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions)) *MockOServiceBOSHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceBOSHandler_ClientVersionsHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions)) *mockOServiceBOSHandler_ClientVersionsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x17_OServiceClientVersions))
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_ClientVersionsHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceBOSHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceBOSHandler_ClientVersionsHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceBOSHandler_ClientVersionsHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_ClientVersionsHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage) *MockOServiceBOSHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceBOSHandler_ClientVersionsHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage) *mockOServiceBOSHandler_ClientVersionsHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // IdleNotificationHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceBOSHandler) IdleNotificationHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
+func (_m *mockOServiceBOSHandler) IdleNotificationHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
@@ -125,8 +125,8 @@ func (_m *MockOServiceBOSHandler) IdleNotificationHandler(ctx context.Context, s
 	return r0
 }
 
-// MockOServiceBOSHandler_IdleNotificationHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IdleNotificationHandler'
-type MockOServiceBOSHandler_IdleNotificationHandler_Call struct {
+// mockOServiceBOSHandler_IdleNotificationHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IdleNotificationHandler'
+type mockOServiceBOSHandler_IdleNotificationHandler_Call struct {
 	*mock.Call
 }
 
@@ -134,29 +134,29 @@ type MockOServiceBOSHandler_IdleNotificationHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification
-func (_e *MockOServiceBOSHandler_Expecter) IdleNotificationHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockOServiceBOSHandler_IdleNotificationHandler_Call {
-	return &MockOServiceBOSHandler_IdleNotificationHandler_Call{Call: _e.mock.On("IdleNotificationHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockOServiceBOSHandler_Expecter) IdleNotificationHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockOServiceBOSHandler_IdleNotificationHandler_Call {
+	return &mockOServiceBOSHandler_IdleNotificationHandler_Call{Call: _e.mock.On("IdleNotificationHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockOServiceBOSHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceBOSHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceBOSHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *mockOServiceBOSHandler_IdleNotificationHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_IdleNotificationHandler_Call) Return(_a0 error) *MockOServiceBOSHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceBOSHandler_IdleNotificationHandler_Call) Return(_a0 error) *mockOServiceBOSHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceBOSHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceBOSHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *mockOServiceBOSHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RateParamsQueryHandler provides a mock function with given fields: ctx
-func (_m *MockOServiceBOSHandler) RateParamsQueryHandler(ctx context.Context) oscar.XMessage {
+func (_m *mockOServiceBOSHandler) RateParamsQueryHandler(ctx context.Context) oscar.XMessage {
 	ret := _m.Called(ctx)
 
 	var r0 oscar.XMessage
@@ -169,70 +169,70 @@ func (_m *MockOServiceBOSHandler) RateParamsQueryHandler(ctx context.Context) os
 	return r0
 }
 
-// MockOServiceBOSHandler_RateParamsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsQueryHandler'
-type MockOServiceBOSHandler_RateParamsQueryHandler_Call struct {
+// mockOServiceBOSHandler_RateParamsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsQueryHandler'
+type mockOServiceBOSHandler_RateParamsQueryHandler_Call struct {
 	*mock.Call
 }
 
 // RateParamsQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-func (_e *MockOServiceBOSHandler_Expecter) RateParamsQueryHandler(ctx interface{}) *MockOServiceBOSHandler_RateParamsQueryHandler_Call {
-	return &MockOServiceBOSHandler_RateParamsQueryHandler_Call{Call: _e.mock.On("RateParamsQueryHandler", ctx)}
+func (_e *mockOServiceBOSHandler_Expecter) RateParamsQueryHandler(ctx interface{}) *mockOServiceBOSHandler_RateParamsQueryHandler_Call {
+	return &mockOServiceBOSHandler_RateParamsQueryHandler_Call{Call: _e.mock.On("RateParamsQueryHandler", ctx)}
 }
 
-func (_c *MockOServiceBOSHandler_RateParamsQueryHandler_Call) Run(run func(ctx context.Context)) *MockOServiceBOSHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceBOSHandler_RateParamsQueryHandler_Call) Run(run func(ctx context.Context)) *mockOServiceBOSHandler_RateParamsQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_RateParamsQueryHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceBOSHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceBOSHandler_RateParamsQueryHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceBOSHandler_RateParamsQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_RateParamsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockOServiceBOSHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceBOSHandler_RateParamsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockOServiceBOSHandler_RateParamsQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RateParamsSubAddHandler provides a mock function with given fields: _a0, _a1
-func (_m *MockOServiceBOSHandler) RateParamsSubAddHandler(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd) {
+func (_m *mockOServiceBOSHandler) RateParamsSubAddHandler(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd) {
 	_m.Called(_a0, _a1)
 }
 
-// MockOServiceBOSHandler_RateParamsSubAddHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsSubAddHandler'
-type MockOServiceBOSHandler_RateParamsSubAddHandler_Call struct {
+// mockOServiceBOSHandler_RateParamsSubAddHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsSubAddHandler'
+type mockOServiceBOSHandler_RateParamsSubAddHandler_Call struct {
 	*mock.Call
 }
 
 // RateParamsSubAddHandler is a helper method to define mock.On call
 //   - _a0 context.Context
 //   - _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd
-func (_e *MockOServiceBOSHandler_Expecter) RateParamsSubAddHandler(_a0 interface{}, _a1 interface{}) *MockOServiceBOSHandler_RateParamsSubAddHandler_Call {
-	return &MockOServiceBOSHandler_RateParamsSubAddHandler_Call{Call: _e.mock.On("RateParamsSubAddHandler", _a0, _a1)}
+func (_e *mockOServiceBOSHandler_Expecter) RateParamsSubAddHandler(_a0 interface{}, _a1 interface{}) *mockOServiceBOSHandler_RateParamsSubAddHandler_Call {
+	return &mockOServiceBOSHandler_RateParamsSubAddHandler_Call{Call: _e.mock.On("RateParamsSubAddHandler", _a0, _a1)}
 }
 
-func (_c *MockOServiceBOSHandler_RateParamsSubAddHandler_Call) Run(run func(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *MockOServiceBOSHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceBOSHandler_RateParamsSubAddHandler_Call) Run(run func(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *mockOServiceBOSHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd))
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_RateParamsSubAddHandler_Call) Return() *MockOServiceBOSHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceBOSHandler_RateParamsSubAddHandler_Call) Return() *mockOServiceBOSHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_RateParamsSubAddHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *MockOServiceBOSHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceBOSHandler_RateParamsSubAddHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *mockOServiceBOSHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // ServiceRequestHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceBOSHandler) ServiceRequestHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
+func (_m *mockOServiceBOSHandler) ServiceRequestHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -255,8 +255,8 @@ func (_m *MockOServiceBOSHandler) ServiceRequestHandler(ctx context.Context, ses
 	return r0, r1
 }
 
-// MockOServiceBOSHandler_ServiceRequestHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceRequestHandler'
-type MockOServiceBOSHandler_ServiceRequestHandler_Call struct {
+// mockOServiceBOSHandler_ServiceRequestHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceRequestHandler'
+type mockOServiceBOSHandler_ServiceRequestHandler_Call struct {
 	*mock.Call
 }
 
@@ -264,29 +264,29 @@ type MockOServiceBOSHandler_ServiceRequestHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest
-func (_e *MockOServiceBOSHandler_Expecter) ServiceRequestHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockOServiceBOSHandler_ServiceRequestHandler_Call {
-	return &MockOServiceBOSHandler_ServiceRequestHandler_Call{Call: _e.mock.On("ServiceRequestHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockOServiceBOSHandler_Expecter) ServiceRequestHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockOServiceBOSHandler_ServiceRequestHandler_Call {
+	return &mockOServiceBOSHandler_ServiceRequestHandler_Call{Call: _e.mock.On("ServiceRequestHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockOServiceBOSHandler_ServiceRequestHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest)) *MockOServiceBOSHandler_ServiceRequestHandler_Call {
+func (_c *mockOServiceBOSHandler_ServiceRequestHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest)) *mockOServiceBOSHandler_ServiceRequestHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x01_0x04_OServiceServiceRequest))
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_ServiceRequestHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockOServiceBOSHandler_ServiceRequestHandler_Call {
+func (_c *mockOServiceBOSHandler_ServiceRequestHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockOServiceBOSHandler_ServiceRequestHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_ServiceRequestHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)) *MockOServiceBOSHandler_ServiceRequestHandler_Call {
+func (_c *mockOServiceBOSHandler_ServiceRequestHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)) *mockOServiceBOSHandler_ServiceRequestHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // SetUserInfoFieldsHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceBOSHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
+func (_m *mockOServiceBOSHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -309,8 +309,8 @@ func (_m *MockOServiceBOSHandler) SetUserInfoFieldsHandler(ctx context.Context,
 	return r0, r1
 }
 
-// MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserInfoFieldsHandler'
-type MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call struct {
+// mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserInfoFieldsHandler'
+type mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call struct {
 	*mock.Call
 }
 
@@ -318,29 +318,29 @@ type MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields
-func (_e *MockOServiceBOSHandler_Expecter) SetUserInfoFieldsHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
-	return &MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call{Call: _e.mock.On("SetUserInfoFieldsHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockOServiceBOSHandler_Expecter) SetUserInfoFieldsHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
+	return &mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call{Call: _e.mock.On("SetUserInfoFieldsHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *mockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // UserInfoQueryHandler provides a mock function with given fields: ctx, sess
-func (_m *MockOServiceBOSHandler) UserInfoQueryHandler(ctx context.Context, sess *state.Session) oscar.XMessage {
+func (_m *mockOServiceBOSHandler) UserInfoQueryHandler(ctx context.Context, sess *state.Session) oscar.XMessage {
 	ret := _m.Called(ctx, sess)
 
 	var r0 oscar.XMessage
@@ -353,37 +353,37 @@ func (_m *MockOServiceBOSHandler) UserInfoQueryHandler(ctx context.Context, sess
 	return r0
 }
 
-// MockOServiceBOSHandler_UserInfoQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserInfoQueryHandler'
-type MockOServiceBOSHandler_UserInfoQueryHandler_Call struct {
+// mockOServiceBOSHandler_UserInfoQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserInfoQueryHandler'
+type mockOServiceBOSHandler_UserInfoQueryHandler_Call struct {
 	*mock.Call
 }
 
 // UserInfoQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - sess *state.Session
-func (_e *MockOServiceBOSHandler_Expecter) UserInfoQueryHandler(ctx interface{}, sess interface{}) *MockOServiceBOSHandler_UserInfoQueryHandler_Call {
-	return &MockOServiceBOSHandler_UserInfoQueryHandler_Call{Call: _e.mock.On("UserInfoQueryHandler", ctx, sess)}
+func (_e *mockOServiceBOSHandler_Expecter) UserInfoQueryHandler(ctx interface{}, sess interface{}) *mockOServiceBOSHandler_UserInfoQueryHandler_Call {
+	return &mockOServiceBOSHandler_UserInfoQueryHandler_Call{Call: _e.mock.On("UserInfoQueryHandler", ctx, sess)}
 }
 
-func (_c *MockOServiceBOSHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *state.Session)) *MockOServiceBOSHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceBOSHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *state.Session)) *mockOServiceBOSHandler_UserInfoQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session))
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceBOSHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceBOSHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceBOSHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *state.Session) oscar.XMessage) *MockOServiceBOSHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceBOSHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *state.Session) oscar.XMessage) *mockOServiceBOSHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // WriteOServiceHostOnline provides a mock function with given fields:
-func (_m *MockOServiceBOSHandler) WriteOServiceHostOnline() oscar.XMessage {
+func (_m *mockOServiceBOSHandler) WriteOServiceHostOnline() oscar.XMessage {
 	ret := _m.Called()
 
 	var r0 oscar.XMessage
@@ -396,40 +396,40 @@ func (_m *MockOServiceBOSHandler) WriteOServiceHostOnline() oscar.XMessage {
 	return r0
 }
 
-// MockOServiceBOSHandler_WriteOServiceHostOnline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOServiceHostOnline'
-type MockOServiceBOSHandler_WriteOServiceHostOnline_Call struct {
+// mockOServiceBOSHandler_WriteOServiceHostOnline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOServiceHostOnline'
+type mockOServiceBOSHandler_WriteOServiceHostOnline_Call struct {
 	*mock.Call
 }
 
 // WriteOServiceHostOnline is a helper method to define mock.On call
-func (_e *MockOServiceBOSHandler_Expecter) WriteOServiceHostOnline() *MockOServiceBOSHandler_WriteOServiceHostOnline_Call {
-	return &MockOServiceBOSHandler_WriteOServiceHostOnline_Call{Call: _e.mock.On("WriteOServiceHostOnline")}
+func (_e *mockOServiceBOSHandler_Expecter) WriteOServiceHostOnline() *mockOServiceBOSHandler_WriteOServiceHostOnline_Call {
+	return &mockOServiceBOSHandler_WriteOServiceHostOnline_Call{Call: _e.mock.On("WriteOServiceHostOnline")}
 }
 
-func (_c *MockOServiceBOSHandler_WriteOServiceHostOnline_Call) Run(run func()) *MockOServiceBOSHandler_WriteOServiceHostOnline_Call {
+func (_c *mockOServiceBOSHandler_WriteOServiceHostOnline_Call) Run(run func()) *mockOServiceBOSHandler_WriteOServiceHostOnline_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run()
 	})
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_WriteOServiceHostOnline_Call) Return(_a0 oscar.XMessage) *MockOServiceBOSHandler_WriteOServiceHostOnline_Call {
+func (_c *mockOServiceBOSHandler_WriteOServiceHostOnline_Call) Return(_a0 oscar.XMessage) *mockOServiceBOSHandler_WriteOServiceHostOnline_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_WriteOServiceHostOnline_Call) RunAndReturn(run func() oscar.XMessage) *MockOServiceBOSHandler_WriteOServiceHostOnline_Call {
+func (_c *mockOServiceBOSHandler_WriteOServiceHostOnline_Call) RunAndReturn(run func() oscar.XMessage) *mockOServiceBOSHandler_WriteOServiceHostOnline_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockOServiceBOSHandler creates a new instance of MockOServiceBOSHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockOServiceBOSHandler creates a new instance of mockOServiceBOSHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockOServiceBOSHandler(t interface {
+func newMockOServiceBOSHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockOServiceBOSHandler {
-	mock := &MockOServiceBOSHandler{}
+}) *mockOServiceBOSHandler {
+	mock := &mockOServiceBOSHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/oservice_chat_mock.go

@@ -11,21 +11,21 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockOServiceChatHandler is an autogenerated mock type for the OServiceChatHandler type
-type MockOServiceChatHandler struct {
+// mockOServiceChatHandler is an autogenerated mock type for the OServiceChatHandler type
+type mockOServiceChatHandler struct {
 	mock.Mock
 }
 
-type MockOServiceChatHandler_Expecter struct {
+type mockOServiceChatHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockOServiceChatHandler) EXPECT() *MockOServiceChatHandler_Expecter {
-	return &MockOServiceChatHandler_Expecter{mock: &_m.Mock}
+func (_m *mockOServiceChatHandler) EXPECT() *mockOServiceChatHandler_Expecter {
+	return &mockOServiceChatHandler_Expecter{mock: &_m.Mock}
 }
 
 // ClientOnlineHandler provides a mock function with given fields: ctx, snacPayloadIn, sess, chatID
-func (_m *MockOServiceChatHandler) ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *state.Session, chatID string) error {
+func (_m *mockOServiceChatHandler) ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *state.Session, chatID string) error {
 	ret := _m.Called(ctx, snacPayloadIn, sess, chatID)
 
 	var r0 error
@@ -38,8 +38,8 @@ func (_m *MockOServiceChatHandler) ClientOnlineHandler(ctx context.Context, snac
 	return r0
 }
 
-// MockOServiceChatHandler_ClientOnlineHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientOnlineHandler'
-type MockOServiceChatHandler_ClientOnlineHandler_Call struct {
+// mockOServiceChatHandler_ClientOnlineHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientOnlineHandler'
+type mockOServiceChatHandler_ClientOnlineHandler_Call struct {
 	*mock.Call
 }
 
@@ -48,29 +48,29 @@ type MockOServiceChatHandler_ClientOnlineHandler_Call struct {
 //   - snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline
 //   - sess *state.Session
 //   - chatID string
-func (_e *MockOServiceChatHandler_Expecter) ClientOnlineHandler(ctx interface{}, snacPayloadIn interface{}, sess interface{}, chatID interface{}) *MockOServiceChatHandler_ClientOnlineHandler_Call {
-	return &MockOServiceChatHandler_ClientOnlineHandler_Call{Call: _e.mock.On("ClientOnlineHandler", ctx, snacPayloadIn, sess, chatID)}
+func (_e *mockOServiceChatHandler_Expecter) ClientOnlineHandler(ctx interface{}, snacPayloadIn interface{}, sess interface{}, chatID interface{}) *mockOServiceChatHandler_ClientOnlineHandler_Call {
+	return &mockOServiceChatHandler_ClientOnlineHandler_Call{Call: _e.mock.On("ClientOnlineHandler", ctx, snacPayloadIn, sess, chatID)}
 }
 
-func (_c *MockOServiceChatHandler_ClientOnlineHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *state.Session, chatID string)) *MockOServiceChatHandler_ClientOnlineHandler_Call {
+func (_c *mockOServiceChatHandler_ClientOnlineHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *state.Session, chatID string)) *mockOServiceChatHandler_ClientOnlineHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x02_OServiceClientOnline), args[2].(*state.Session), args[3].(string))
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_ClientOnlineHandler_Call) Return(_a0 error) *MockOServiceChatHandler_ClientOnlineHandler_Call {
+func (_c *mockOServiceChatHandler_ClientOnlineHandler_Call) Return(_a0 error) *mockOServiceChatHandler_ClientOnlineHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_ClientOnlineHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *state.Session, string) error) *MockOServiceChatHandler_ClientOnlineHandler_Call {
+func (_c *mockOServiceChatHandler_ClientOnlineHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *state.Session, string) error) *mockOServiceChatHandler_ClientOnlineHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // ClientVersionsHandler provides a mock function with given fields: ctx, snacPayloadIn
-func (_m *MockOServiceChatHandler) ClientVersionsHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage {
+func (_m *mockOServiceChatHandler) ClientVersionsHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage {
 	ret := _m.Called(ctx, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -83,37 +83,37 @@ func (_m *MockOServiceChatHandler) ClientVersionsHandler(ctx context.Context, sn
 	return r0
 }
 
-// MockOServiceChatHandler_ClientVersionsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientVersionsHandler'
-type MockOServiceChatHandler_ClientVersionsHandler_Call struct {
+// mockOServiceChatHandler_ClientVersionsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientVersionsHandler'
+type mockOServiceChatHandler_ClientVersionsHandler_Call struct {
 	*mock.Call
 }
 
 // ClientVersionsHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions
-func (_e *MockOServiceChatHandler_Expecter) ClientVersionsHandler(ctx interface{}, snacPayloadIn interface{}) *MockOServiceChatHandler_ClientVersionsHandler_Call {
-	return &MockOServiceChatHandler_ClientVersionsHandler_Call{Call: _e.mock.On("ClientVersionsHandler", ctx, snacPayloadIn)}
+func (_e *mockOServiceChatHandler_Expecter) ClientVersionsHandler(ctx interface{}, snacPayloadIn interface{}) *mockOServiceChatHandler_ClientVersionsHandler_Call {
+	return &mockOServiceChatHandler_ClientVersionsHandler_Call{Call: _e.mock.On("ClientVersionsHandler", ctx, snacPayloadIn)}
 }
 
-func (_c *MockOServiceChatHandler_ClientVersionsHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions)) *MockOServiceChatHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceChatHandler_ClientVersionsHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions)) *mockOServiceChatHandler_ClientVersionsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x17_OServiceClientVersions))
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_ClientVersionsHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceChatHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceChatHandler_ClientVersionsHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceChatHandler_ClientVersionsHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_ClientVersionsHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage) *MockOServiceChatHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceChatHandler_ClientVersionsHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage) *mockOServiceChatHandler_ClientVersionsHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // IdleNotificationHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceChatHandler) IdleNotificationHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
+func (_m *mockOServiceChatHandler) IdleNotificationHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
@@ -126,8 +126,8 @@ func (_m *MockOServiceChatHandler) IdleNotificationHandler(ctx context.Context,
 	return r0
 }
 
-// MockOServiceChatHandler_IdleNotificationHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IdleNotificationHandler'
-type MockOServiceChatHandler_IdleNotificationHandler_Call struct {
+// mockOServiceChatHandler_IdleNotificationHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IdleNotificationHandler'
+type mockOServiceChatHandler_IdleNotificationHandler_Call struct {
 	*mock.Call
 }
 
@@ -135,29 +135,29 @@ type MockOServiceChatHandler_IdleNotificationHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification
-func (_e *MockOServiceChatHandler_Expecter) IdleNotificationHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockOServiceChatHandler_IdleNotificationHandler_Call {
-	return &MockOServiceChatHandler_IdleNotificationHandler_Call{Call: _e.mock.On("IdleNotificationHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockOServiceChatHandler_Expecter) IdleNotificationHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockOServiceChatHandler_IdleNotificationHandler_Call {
+	return &mockOServiceChatHandler_IdleNotificationHandler_Call{Call: _e.mock.On("IdleNotificationHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockOServiceChatHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceChatHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceChatHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *mockOServiceChatHandler_IdleNotificationHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_IdleNotificationHandler_Call) Return(_a0 error) *MockOServiceChatHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceChatHandler_IdleNotificationHandler_Call) Return(_a0 error) *mockOServiceChatHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceChatHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceChatHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *mockOServiceChatHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RateParamsQueryHandler provides a mock function with given fields: ctx
-func (_m *MockOServiceChatHandler) RateParamsQueryHandler(ctx context.Context) oscar.XMessage {
+func (_m *mockOServiceChatHandler) RateParamsQueryHandler(ctx context.Context) oscar.XMessage {
 	ret := _m.Called(ctx)
 
 	var r0 oscar.XMessage
@@ -170,70 +170,70 @@ func (_m *MockOServiceChatHandler) RateParamsQueryHandler(ctx context.Context) o
 	return r0
 }
 
-// MockOServiceChatHandler_RateParamsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsQueryHandler'
-type MockOServiceChatHandler_RateParamsQueryHandler_Call struct {
+// mockOServiceChatHandler_RateParamsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsQueryHandler'
+type mockOServiceChatHandler_RateParamsQueryHandler_Call struct {
 	*mock.Call
 }
 
 // RateParamsQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-func (_e *MockOServiceChatHandler_Expecter) RateParamsQueryHandler(ctx interface{}) *MockOServiceChatHandler_RateParamsQueryHandler_Call {
-	return &MockOServiceChatHandler_RateParamsQueryHandler_Call{Call: _e.mock.On("RateParamsQueryHandler", ctx)}
+func (_e *mockOServiceChatHandler_Expecter) RateParamsQueryHandler(ctx interface{}) *mockOServiceChatHandler_RateParamsQueryHandler_Call {
+	return &mockOServiceChatHandler_RateParamsQueryHandler_Call{Call: _e.mock.On("RateParamsQueryHandler", ctx)}
 }
 
-func (_c *MockOServiceChatHandler_RateParamsQueryHandler_Call) Run(run func(ctx context.Context)) *MockOServiceChatHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceChatHandler_RateParamsQueryHandler_Call) Run(run func(ctx context.Context)) *mockOServiceChatHandler_RateParamsQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_RateParamsQueryHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceChatHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceChatHandler_RateParamsQueryHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceChatHandler_RateParamsQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_RateParamsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockOServiceChatHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceChatHandler_RateParamsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockOServiceChatHandler_RateParamsQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RateParamsSubAddHandler provides a mock function with given fields: _a0, _a1
-func (_m *MockOServiceChatHandler) RateParamsSubAddHandler(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd) {
+func (_m *mockOServiceChatHandler) RateParamsSubAddHandler(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd) {
 	_m.Called(_a0, _a1)
 }
 
-// MockOServiceChatHandler_RateParamsSubAddHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsSubAddHandler'
-type MockOServiceChatHandler_RateParamsSubAddHandler_Call struct {
+// mockOServiceChatHandler_RateParamsSubAddHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsSubAddHandler'
+type mockOServiceChatHandler_RateParamsSubAddHandler_Call struct {
 	*mock.Call
 }
 
 // RateParamsSubAddHandler is a helper method to define mock.On call
 //   - _a0 context.Context
 //   - _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd
-func (_e *MockOServiceChatHandler_Expecter) RateParamsSubAddHandler(_a0 interface{}, _a1 interface{}) *MockOServiceChatHandler_RateParamsSubAddHandler_Call {
-	return &MockOServiceChatHandler_RateParamsSubAddHandler_Call{Call: _e.mock.On("RateParamsSubAddHandler", _a0, _a1)}
+func (_e *mockOServiceChatHandler_Expecter) RateParamsSubAddHandler(_a0 interface{}, _a1 interface{}) *mockOServiceChatHandler_RateParamsSubAddHandler_Call {
+	return &mockOServiceChatHandler_RateParamsSubAddHandler_Call{Call: _e.mock.On("RateParamsSubAddHandler", _a0, _a1)}
 }
 
-func (_c *MockOServiceChatHandler_RateParamsSubAddHandler_Call) Run(run func(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *MockOServiceChatHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceChatHandler_RateParamsSubAddHandler_Call) Run(run func(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *mockOServiceChatHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd))
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_RateParamsSubAddHandler_Call) Return() *MockOServiceChatHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceChatHandler_RateParamsSubAddHandler_Call) Return() *mockOServiceChatHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_RateParamsSubAddHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *MockOServiceChatHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceChatHandler_RateParamsSubAddHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *mockOServiceChatHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // ServiceRequestHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceChatHandler) ServiceRequestHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
+func (_m *mockOServiceChatHandler) ServiceRequestHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -256,8 +256,8 @@ func (_m *MockOServiceChatHandler) ServiceRequestHandler(ctx context.Context, se
 	return r0, r1
 }
 
-// MockOServiceChatHandler_ServiceRequestHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceRequestHandler'
-type MockOServiceChatHandler_ServiceRequestHandler_Call struct {
+// mockOServiceChatHandler_ServiceRequestHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ServiceRequestHandler'
+type mockOServiceChatHandler_ServiceRequestHandler_Call struct {
 	*mock.Call
 }
 
@@ -265,29 +265,29 @@ type MockOServiceChatHandler_ServiceRequestHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest
-func (_e *MockOServiceChatHandler_Expecter) ServiceRequestHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockOServiceChatHandler_ServiceRequestHandler_Call {
-	return &MockOServiceChatHandler_ServiceRequestHandler_Call{Call: _e.mock.On("ServiceRequestHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockOServiceChatHandler_Expecter) ServiceRequestHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockOServiceChatHandler_ServiceRequestHandler_Call {
+	return &mockOServiceChatHandler_ServiceRequestHandler_Call{Call: _e.mock.On("ServiceRequestHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockOServiceChatHandler_ServiceRequestHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest)) *MockOServiceChatHandler_ServiceRequestHandler_Call {
+func (_c *mockOServiceChatHandler_ServiceRequestHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest)) *mockOServiceChatHandler_ServiceRequestHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x01_0x04_OServiceServiceRequest))
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_ServiceRequestHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockOServiceChatHandler_ServiceRequestHandler_Call {
+func (_c *mockOServiceChatHandler_ServiceRequestHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockOServiceChatHandler_ServiceRequestHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_ServiceRequestHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)) *MockOServiceChatHandler_ServiceRequestHandler_Call {
+func (_c *mockOServiceChatHandler_ServiceRequestHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)) *mockOServiceChatHandler_ServiceRequestHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // SetUserInfoFieldsHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceChatHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
+func (_m *mockOServiceChatHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -310,8 +310,8 @@ func (_m *MockOServiceChatHandler) SetUserInfoFieldsHandler(ctx context.Context,
 	return r0, r1
 }
 
-// MockOServiceChatHandler_SetUserInfoFieldsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserInfoFieldsHandler'
-type MockOServiceChatHandler_SetUserInfoFieldsHandler_Call struct {
+// mockOServiceChatHandler_SetUserInfoFieldsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserInfoFieldsHandler'
+type mockOServiceChatHandler_SetUserInfoFieldsHandler_Call struct {
 	*mock.Call
 }
 
@@ -319,29 +319,29 @@ type MockOServiceChatHandler_SetUserInfoFieldsHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields
-func (_e *MockOServiceChatHandler_Expecter) SetUserInfoFieldsHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
-	return &MockOServiceChatHandler_SetUserInfoFieldsHandler_Call{Call: _e.mock.On("SetUserInfoFieldsHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockOServiceChatHandler_Expecter) SetUserInfoFieldsHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
+	return &mockOServiceChatHandler_SetUserInfoFieldsHandler_Call{Call: _e.mock.On("SetUserInfoFieldsHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceChatHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *mockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceChatHandler_SetUserInfoFieldsHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceChatHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *mockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // UserInfoQueryHandler provides a mock function with given fields: ctx, sess
-func (_m *MockOServiceChatHandler) UserInfoQueryHandler(ctx context.Context, sess *state.Session) oscar.XMessage {
+func (_m *mockOServiceChatHandler) UserInfoQueryHandler(ctx context.Context, sess *state.Session) oscar.XMessage {
 	ret := _m.Called(ctx, sess)
 
 	var r0 oscar.XMessage
@@ -354,37 +354,37 @@ func (_m *MockOServiceChatHandler) UserInfoQueryHandler(ctx context.Context, ses
 	return r0
 }
 
-// MockOServiceChatHandler_UserInfoQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserInfoQueryHandler'
-type MockOServiceChatHandler_UserInfoQueryHandler_Call struct {
+// mockOServiceChatHandler_UserInfoQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserInfoQueryHandler'
+type mockOServiceChatHandler_UserInfoQueryHandler_Call struct {
 	*mock.Call
 }
 
 // UserInfoQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - sess *state.Session
-func (_e *MockOServiceChatHandler_Expecter) UserInfoQueryHandler(ctx interface{}, sess interface{}) *MockOServiceChatHandler_UserInfoQueryHandler_Call {
-	return &MockOServiceChatHandler_UserInfoQueryHandler_Call{Call: _e.mock.On("UserInfoQueryHandler", ctx, sess)}
+func (_e *mockOServiceChatHandler_Expecter) UserInfoQueryHandler(ctx interface{}, sess interface{}) *mockOServiceChatHandler_UserInfoQueryHandler_Call {
+	return &mockOServiceChatHandler_UserInfoQueryHandler_Call{Call: _e.mock.On("UserInfoQueryHandler", ctx, sess)}
 }
 
-func (_c *MockOServiceChatHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *state.Session)) *MockOServiceChatHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceChatHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *state.Session)) *mockOServiceChatHandler_UserInfoQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session))
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceChatHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceChatHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceChatHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *state.Session) oscar.XMessage) *MockOServiceChatHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceChatHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *state.Session) oscar.XMessage) *mockOServiceChatHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // WriteOServiceHostOnline provides a mock function with given fields:
-func (_m *MockOServiceChatHandler) WriteOServiceHostOnline() oscar.XMessage {
+func (_m *mockOServiceChatHandler) WriteOServiceHostOnline() oscar.XMessage {
 	ret := _m.Called()
 
 	var r0 oscar.XMessage
@@ -397,40 +397,40 @@ func (_m *MockOServiceChatHandler) WriteOServiceHostOnline() oscar.XMessage {
 	return r0
 }
 
-// MockOServiceChatHandler_WriteOServiceHostOnline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOServiceHostOnline'
-type MockOServiceChatHandler_WriteOServiceHostOnline_Call struct {
+// mockOServiceChatHandler_WriteOServiceHostOnline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteOServiceHostOnline'
+type mockOServiceChatHandler_WriteOServiceHostOnline_Call struct {
 	*mock.Call
 }
 
 // WriteOServiceHostOnline is a helper method to define mock.On call
-func (_e *MockOServiceChatHandler_Expecter) WriteOServiceHostOnline() *MockOServiceChatHandler_WriteOServiceHostOnline_Call {
-	return &MockOServiceChatHandler_WriteOServiceHostOnline_Call{Call: _e.mock.On("WriteOServiceHostOnline")}
+func (_e *mockOServiceChatHandler_Expecter) WriteOServiceHostOnline() *mockOServiceChatHandler_WriteOServiceHostOnline_Call {
+	return &mockOServiceChatHandler_WriteOServiceHostOnline_Call{Call: _e.mock.On("WriteOServiceHostOnline")}
 }
 
-func (_c *MockOServiceChatHandler_WriteOServiceHostOnline_Call) Run(run func()) *MockOServiceChatHandler_WriteOServiceHostOnline_Call {
+func (_c *mockOServiceChatHandler_WriteOServiceHostOnline_Call) Run(run func()) *mockOServiceChatHandler_WriteOServiceHostOnline_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run()
 	})
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_WriteOServiceHostOnline_Call) Return(_a0 oscar.XMessage) *MockOServiceChatHandler_WriteOServiceHostOnline_Call {
+func (_c *mockOServiceChatHandler_WriteOServiceHostOnline_Call) Return(_a0 oscar.XMessage) *mockOServiceChatHandler_WriteOServiceHostOnline_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_WriteOServiceHostOnline_Call) RunAndReturn(run func() oscar.XMessage) *MockOServiceChatHandler_WriteOServiceHostOnline_Call {
+func (_c *mockOServiceChatHandler_WriteOServiceHostOnline_Call) RunAndReturn(run func() oscar.XMessage) *mockOServiceChatHandler_WriteOServiceHostOnline_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockOServiceChatHandler creates a new instance of MockOServiceChatHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockOServiceChatHandler creates a new instance of mockOServiceChatHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockOServiceChatHandler(t interface {
+func newMockOServiceChatHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockOServiceChatHandler {
-	mock := &MockOServiceChatHandler{}
+}) *mockOServiceChatHandler {
+	mock := &mockOServiceChatHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/oservice_mock.go

@@ -11,21 +11,21 @@ import (
 	state "github.com/mkaminski/goaim/state"
 )
 
-// MockOServiceHandler is an autogenerated mock type for the OServiceHandler type
-type MockOServiceHandler struct {
+// mockOServiceHandler is an autogenerated mock type for the OServiceHandler type
+type mockOServiceHandler struct {
 	mock.Mock
 }
 
-type MockOServiceHandler_Expecter struct {
+type mockOServiceHandler_Expecter struct {
 	mock *mock.Mock
 }
 
-func (_m *MockOServiceHandler) EXPECT() *MockOServiceHandler_Expecter {
-	return &MockOServiceHandler_Expecter{mock: &_m.Mock}
+func (_m *mockOServiceHandler) EXPECT() *mockOServiceHandler_Expecter {
+	return &mockOServiceHandler_Expecter{mock: &_m.Mock}
 }
 
 // ClientVersionsHandler provides a mock function with given fields: ctx, snacPayloadIn
-func (_m *MockOServiceHandler) ClientVersionsHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage {
+func (_m *mockOServiceHandler) ClientVersionsHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage {
 	ret := _m.Called(ctx, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -38,37 +38,37 @@ func (_m *MockOServiceHandler) ClientVersionsHandler(ctx context.Context, snacPa
 	return r0
 }
 
-// MockOServiceHandler_ClientVersionsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientVersionsHandler'
-type MockOServiceHandler_ClientVersionsHandler_Call struct {
+// mockOServiceHandler_ClientVersionsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClientVersionsHandler'
+type mockOServiceHandler_ClientVersionsHandler_Call struct {
 	*mock.Call
 }
 
 // ClientVersionsHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions
-func (_e *MockOServiceHandler_Expecter) ClientVersionsHandler(ctx interface{}, snacPayloadIn interface{}) *MockOServiceHandler_ClientVersionsHandler_Call {
-	return &MockOServiceHandler_ClientVersionsHandler_Call{Call: _e.mock.On("ClientVersionsHandler", ctx, snacPayloadIn)}
+func (_e *mockOServiceHandler_Expecter) ClientVersionsHandler(ctx interface{}, snacPayloadIn interface{}) *mockOServiceHandler_ClientVersionsHandler_Call {
+	return &mockOServiceHandler_ClientVersionsHandler_Call{Call: _e.mock.On("ClientVersionsHandler", ctx, snacPayloadIn)}
 }
 
-func (_c *MockOServiceHandler_ClientVersionsHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions)) *MockOServiceHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceHandler_ClientVersionsHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions)) *mockOServiceHandler_ClientVersionsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x17_OServiceClientVersions))
 	})
 	return _c
 }
 
-func (_c *MockOServiceHandler_ClientVersionsHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceHandler_ClientVersionsHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceHandler_ClientVersionsHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceHandler_ClientVersionsHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage) *MockOServiceHandler_ClientVersionsHandler_Call {
+func (_c *mockOServiceHandler_ClientVersionsHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage) *mockOServiceHandler_ClientVersionsHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // IdleNotificationHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceHandler) IdleNotificationHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
+func (_m *mockOServiceHandler) IdleNotificationHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
@@ -81,8 +81,8 @@ func (_m *MockOServiceHandler) IdleNotificationHandler(ctx context.Context, sess
 	return r0
 }
 
-// MockOServiceHandler_IdleNotificationHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IdleNotificationHandler'
-type MockOServiceHandler_IdleNotificationHandler_Call struct {
+// mockOServiceHandler_IdleNotificationHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IdleNotificationHandler'
+type mockOServiceHandler_IdleNotificationHandler_Call struct {
 	*mock.Call
 }
 
@@ -90,29 +90,29 @@ type MockOServiceHandler_IdleNotificationHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification
-func (_e *MockOServiceHandler_Expecter) IdleNotificationHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockOServiceHandler_IdleNotificationHandler_Call {
-	return &MockOServiceHandler_IdleNotificationHandler_Call{Call: _e.mock.On("IdleNotificationHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockOServiceHandler_Expecter) IdleNotificationHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockOServiceHandler_IdleNotificationHandler_Call {
+	return &mockOServiceHandler_IdleNotificationHandler_Call{Call: _e.mock.On("IdleNotificationHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockOServiceHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *mockOServiceHandler_IdleNotificationHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
 	})
 	return _c
 }
 
-func (_c *MockOServiceHandler_IdleNotificationHandler_Call) Return(_a0 error) *MockOServiceHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceHandler_IdleNotificationHandler_Call) Return(_a0 error) *mockOServiceHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceHandler_IdleNotificationHandler_Call {
+func (_c *mockOServiceHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *mockOServiceHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RateParamsQueryHandler provides a mock function with given fields: ctx
-func (_m *MockOServiceHandler) RateParamsQueryHandler(ctx context.Context) oscar.XMessage {
+func (_m *mockOServiceHandler) RateParamsQueryHandler(ctx context.Context) oscar.XMessage {
 	ret := _m.Called(ctx)
 
 	var r0 oscar.XMessage
@@ -125,70 +125,70 @@ func (_m *MockOServiceHandler) RateParamsQueryHandler(ctx context.Context) oscar
 	return r0
 }
 
-// MockOServiceHandler_RateParamsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsQueryHandler'
-type MockOServiceHandler_RateParamsQueryHandler_Call struct {
+// mockOServiceHandler_RateParamsQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsQueryHandler'
+type mockOServiceHandler_RateParamsQueryHandler_Call struct {
 	*mock.Call
 }
 
 // RateParamsQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-func (_e *MockOServiceHandler_Expecter) RateParamsQueryHandler(ctx interface{}) *MockOServiceHandler_RateParamsQueryHandler_Call {
-	return &MockOServiceHandler_RateParamsQueryHandler_Call{Call: _e.mock.On("RateParamsQueryHandler", ctx)}
+func (_e *mockOServiceHandler_Expecter) RateParamsQueryHandler(ctx interface{}) *mockOServiceHandler_RateParamsQueryHandler_Call {
+	return &mockOServiceHandler_RateParamsQueryHandler_Call{Call: _e.mock.On("RateParamsQueryHandler", ctx)}
 }
 
-func (_c *MockOServiceHandler_RateParamsQueryHandler_Call) Run(run func(ctx context.Context)) *MockOServiceHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceHandler_RateParamsQueryHandler_Call) Run(run func(ctx context.Context)) *mockOServiceHandler_RateParamsQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context))
 	})
 	return _c
 }
 
-func (_c *MockOServiceHandler_RateParamsQueryHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceHandler_RateParamsQueryHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceHandler_RateParamsQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceHandler_RateParamsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *MockOServiceHandler_RateParamsQueryHandler_Call {
+func (_c *mockOServiceHandler_RateParamsQueryHandler_Call) RunAndReturn(run func(context.Context) oscar.XMessage) *mockOServiceHandler_RateParamsQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // RateParamsSubAddHandler provides a mock function with given fields: _a0, _a1
-func (_m *MockOServiceHandler) RateParamsSubAddHandler(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd) {
+func (_m *mockOServiceHandler) RateParamsSubAddHandler(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd) {
 	_m.Called(_a0, _a1)
 }
 
-// MockOServiceHandler_RateParamsSubAddHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsSubAddHandler'
-type MockOServiceHandler_RateParamsSubAddHandler_Call struct {
+// mockOServiceHandler_RateParamsSubAddHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RateParamsSubAddHandler'
+type mockOServiceHandler_RateParamsSubAddHandler_Call struct {
 	*mock.Call
 }
 
 // RateParamsSubAddHandler is a helper method to define mock.On call
 //   - _a0 context.Context
 //   - _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd
-func (_e *MockOServiceHandler_Expecter) RateParamsSubAddHandler(_a0 interface{}, _a1 interface{}) *MockOServiceHandler_RateParamsSubAddHandler_Call {
-	return &MockOServiceHandler_RateParamsSubAddHandler_Call{Call: _e.mock.On("RateParamsSubAddHandler", _a0, _a1)}
+func (_e *mockOServiceHandler_Expecter) RateParamsSubAddHandler(_a0 interface{}, _a1 interface{}) *mockOServiceHandler_RateParamsSubAddHandler_Call {
+	return &mockOServiceHandler_RateParamsSubAddHandler_Call{Call: _e.mock.On("RateParamsSubAddHandler", _a0, _a1)}
 }
 
-func (_c *MockOServiceHandler_RateParamsSubAddHandler_Call) Run(run func(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *MockOServiceHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceHandler_RateParamsSubAddHandler_Call) Run(run func(_a0 context.Context, _a1 oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *mockOServiceHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd))
 	})
 	return _c
 }
 
-func (_c *MockOServiceHandler_RateParamsSubAddHandler_Call) Return() *MockOServiceHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceHandler_RateParamsSubAddHandler_Call) Return() *mockOServiceHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Return()
 	return _c
 }
 
-func (_c *MockOServiceHandler_RateParamsSubAddHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *MockOServiceHandler_RateParamsSubAddHandler_Call {
+func (_c *mockOServiceHandler_RateParamsSubAddHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)) *mockOServiceHandler_RateParamsSubAddHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // SetUserInfoFieldsHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
+func (_m *mockOServiceHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
@@ -211,8 +211,8 @@ func (_m *MockOServiceHandler) SetUserInfoFieldsHandler(ctx context.Context, ses
 	return r0, r1
 }
 
-// MockOServiceHandler_SetUserInfoFieldsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserInfoFieldsHandler'
-type MockOServiceHandler_SetUserInfoFieldsHandler_Call struct {
+// mockOServiceHandler_SetUserInfoFieldsHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUserInfoFieldsHandler'
+type mockOServiceHandler_SetUserInfoFieldsHandler_Call struct {
 	*mock.Call
 }
 
@@ -220,29 +220,29 @@ type MockOServiceHandler_SetUserInfoFieldsHandler_Call struct {
 //   - ctx context.Context
 //   - sess *state.Session
 //   - snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields
-func (_e *MockOServiceHandler_Expecter) SetUserInfoFieldsHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *MockOServiceHandler_SetUserInfoFieldsHandler_Call {
-	return &MockOServiceHandler_SetUserInfoFieldsHandler_Call{Call: _e.mock.On("SetUserInfoFieldsHandler", ctx, sess, snacPayloadIn)}
+func (_e *mockOServiceHandler_Expecter) SetUserInfoFieldsHandler(ctx interface{}, sess interface{}, snacPayloadIn interface{}) *mockOServiceHandler_SetUserInfoFieldsHandler_Call {
+	return &mockOServiceHandler_SetUserInfoFieldsHandler_Call{Call: _e.mock.On("SetUserInfoFieldsHandler", ctx, sess, snacPayloadIn)}
 }
 
-func (_c *MockOServiceHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *state.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *mockOServiceHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
 	})
 	return _c
 }
 
-func (_c *MockOServiceHandler_SetUserInfoFieldsHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *MockOServiceHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceHandler_SetUserInfoFieldsHandler_Call) Return(_a0 oscar.XMessage, _a1 error) *mockOServiceHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockOServiceHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *MockOServiceHandler_SetUserInfoFieldsHandler_Call {
+func (_c *mockOServiceHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *state.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *mockOServiceHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // UserInfoQueryHandler provides a mock function with given fields: ctx, sess
-func (_m *MockOServiceHandler) UserInfoQueryHandler(ctx context.Context, sess *state.Session) oscar.XMessage {
+func (_m *mockOServiceHandler) UserInfoQueryHandler(ctx context.Context, sess *state.Session) oscar.XMessage {
 	ret := _m.Called(ctx, sess)
 
 	var r0 oscar.XMessage
@@ -255,42 +255,42 @@ func (_m *MockOServiceHandler) UserInfoQueryHandler(ctx context.Context, sess *s
 	return r0
 }
 
-// MockOServiceHandler_UserInfoQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserInfoQueryHandler'
-type MockOServiceHandler_UserInfoQueryHandler_Call struct {
+// mockOServiceHandler_UserInfoQueryHandler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserInfoQueryHandler'
+type mockOServiceHandler_UserInfoQueryHandler_Call struct {
 	*mock.Call
 }
 
 // UserInfoQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - sess *state.Session
-func (_e *MockOServiceHandler_Expecter) UserInfoQueryHandler(ctx interface{}, sess interface{}) *MockOServiceHandler_UserInfoQueryHandler_Call {
-	return &MockOServiceHandler_UserInfoQueryHandler_Call{Call: _e.mock.On("UserInfoQueryHandler", ctx, sess)}
+func (_e *mockOServiceHandler_Expecter) UserInfoQueryHandler(ctx interface{}, sess interface{}) *mockOServiceHandler_UserInfoQueryHandler_Call {
+	return &mockOServiceHandler_UserInfoQueryHandler_Call{Call: _e.mock.On("UserInfoQueryHandler", ctx, sess)}
 }
 
-func (_c *MockOServiceHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *state.Session)) *MockOServiceHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *state.Session)) *mockOServiceHandler_UserInfoQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].(*state.Session))
 	})
 	return _c
 }
 
-func (_c *MockOServiceHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XMessage) *MockOServiceHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XMessage) *mockOServiceHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockOServiceHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *state.Session) oscar.XMessage) *MockOServiceHandler_UserInfoQueryHandler_Call {
+func (_c *mockOServiceHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *state.Session) oscar.XMessage) *mockOServiceHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
-// NewMockOServiceHandler creates a new instance of MockOServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// newMockOServiceHandler creates a new instance of mockOServiceHandler. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMockOServiceHandler(t interface {
+func newMockOServiceHandler(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MockOServiceHandler {
-	mock := &MockOServiceHandler{}
+}) *mockOServiceHandler {
+	mock := &mockOServiceHandler{}
 	mock.Mock.Test(t)
 
 	t.Cleanup(func() { mock.AssertExpectations(t) })

server/oservice_test.go

@@ -216,7 +216,7 @@ func TestOServiceRouter_RouteOService_ForBOS(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svc := NewMockOServiceHandler(t)
+			svc := newMockOServiceHandler(t)
 			svc.EXPECT().
 				RateParamsQueryHandler(mock.Anything).
 				Return(tc.output).
@@ -241,7 +241,7 @@ func TestOServiceRouter_RouteOService_ForBOS(t *testing.T) {
 				Return(tc.handlerErr).
 				Maybe()
 
-			svcBOS := NewMockOServiceBOSHandler(t)
+			svcBOS := newMockOServiceBOSHandler(t)
 			svcBOS.EXPECT().
 				ServiceRequestHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
 				Return(tc.output, tc.handlerErr).
@@ -510,7 +510,7 @@ func TestOServiceRouter_RouteOService_ForChat(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svc := NewMockOServiceHandler(t)
+			svc := newMockOServiceHandler(t)
 			svc.EXPECT().
 				RateParamsQueryHandler(mock.Anything).
 				Return(tc.output).
@@ -535,7 +535,7 @@ func TestOServiceRouter_RouteOService_ForChat(t *testing.T) {
 				Return(tc.handlerErr).
 				Maybe()
 
-			svcBOS := NewMockOServiceChatHandler(t)
+			svcBOS := newMockOServiceChatHandler(t)
 			svcBOS.EXPECT().
 				ServiceRequestHandler(mock.Anything, mock.Anything, tc.input.SnacOut).
 				Return(tc.output, tc.handlerErr).

server/router.go

@@ -8,32 +8,21 @@ import (
 	"github.com/mkaminski/goaim/oscar"
 	"github.com/mkaminski/goaim/state"
 	"io"
-	"log/slog"
 	"net"
 )
 
-func NewChatServiceRouter(logger *slog.Logger, cfg Config, oserviceHandler OServiceHandler, chatHandler ChatHandler, oserviceChatHandler OServiceChatHandler) ChatServiceRouter {
-	return ChatServiceRouter{
-		OServiceChatRouter: NewOServiceRouterForChat(logger, oserviceHandler, oserviceChatHandler),
-		ChatRouter:         NewChatRouter(logger, chatHandler),
-		cfg:                cfg,
-		RouteLogger: RouteLogger{
-			Logger: logger,
-		},
-	}
-}
-
 type AuthHandler interface {
-	Signout(ctx context.Context, sess *state.Session) error
-	VerifyLogin(conn net.Conn) (*state.Session, uint32, error)
-	VerifyChatLogin(rw io.ReadWriter) (*ChatCookie, uint32, error)
-	SendAndReceiveSignonFrame(rw io.ReadWriter, sequence *uint32) (oscar.FlapSignonFrame, error)
-	ReceiveAndSendBUCPLoginRequest(snacPayloadIn oscar.SNAC_0x17_0x02_BUCPLoginRequest, newUUID func() uuid.UUID) (oscar.XMessage, error)
 	ReceiveAndSendAuthChallenge(snacPayloadIn oscar.SNAC_0x17_0x06_BUCPChallengeRequest, newUUID func() uuid.UUID) (oscar.XMessage, error)
+	ReceiveAndSendBUCPLoginRequest(snacPayloadIn oscar.SNAC_0x17_0x02_BUCPLoginRequest, newUUID func() uuid.UUID) (oscar.XMessage, error)
+	RetrieveChatSession(ctx context.Context, chatID string, sessID string) (*state.Session, error)
+	SendAndReceiveSignonFrame(rw io.ReadWriter, sequence *uint32) (oscar.FlapSignonFrame, error)
+	Signout(ctx context.Context, sess *state.Session) error
 	SignoutChat(ctx context.Context, sess *state.Session, chatID string)
+	VerifyChatLogin(rw io.ReadWriter) (*ChatCookie, uint32, error)
+	VerifyLogin(conn net.Conn) (*state.Session, uint32, error)
 }
 
-type BOSServiceRouter struct {
+type BOSService struct {
 	AlertRouter
 	AuthHandler
 	BuddyRouter
@@ -46,7 +35,14 @@ type BOSServiceRouter struct {
 	RouteLogger
 }
 
-func (rt *BOSServiceRouter) Route(ctx context.Context, sess *state.Session, r io.Reader, w io.Writer, sequence *uint32) error {
+type BOSServiceManager interface {
+	Route(ctx context.Context, sess *state.Session, r io.Reader, w io.Writer, sequence *uint32) error
+	Signout(ctx context.Context, sess *state.Session) error
+	VerifyLogin(conn net.Conn) (*state.Session, uint32, error)
+	WriteOServiceHostOnline() oscar.XMessage
+}
+
+func (rt BOSService) Route(ctx context.Context, sess *state.Session, r io.Reader, w io.Writer, sequence *uint32) error {
 	snac := oscar.SnacFrame{}
 	if err := oscar.Unmarshal(&snac, r); err != nil {
 		return err
@@ -91,6 +87,55 @@ func (rt *BOSServiceRouter) Route(ctx context.Context, sess *state.Session, r io
 	return err
 }
 
+type ChatService struct {
+	AuthHandler
+	ChatRouter
+	Config Config
+	OServiceChatRouter
+	RouteLogger
+}
+
+type ChatServiceManager interface {
+	RetrieveChatSession(ctx context.Context, chatID string, sessID string) (*state.Session, error)
+	Route(ctx context.Context, sess *state.Session, r io.Reader, w io.Writer, sequence *uint32, chatID string) error
+	SignoutChat(ctx context.Context, sess *state.Session, chatID string)
+	VerifyChatLogin(rw io.ReadWriter) (*ChatCookie, uint32, error)
+	WriteOServiceHostOnline() oscar.XMessage
+}
+
+func (rt ChatService) Route(ctx context.Context, sess *state.Session, r io.Reader, w io.Writer, sequence *uint32, chatID string) error {
+	snac := oscar.SnacFrame{}
+	if err := oscar.Unmarshal(&snac, r); err != nil {
+		return err
+	}
+
+	err := func() error {
+		switch snac.FoodGroup {
+		case oscar.OSERVICE:
+			return rt.RouteOService(ctx, sess, chatID, snac, r, w, sequence)
+		case oscar.CHAT:
+			return rt.RouteChat(ctx, sess, chatID, snac, r, w, sequence)
+		default:
+			return ErrUnsupportedSubGroup
+		}
+	}()
+
+	if err != nil {
+		rt.logRequestError(ctx, snac, err)
+		if errors.Is(err, ErrUnsupportedSubGroup) {
+			if err1 := sendInvalidSNACErr(snac, w, sequence); err1 != nil {
+				err = errors.Join(err1, err)
+			}
+			if rt.Config.FailFast {
+				panic(err.Error())
+			}
+			return nil
+		}
+	}
+
+	return err
+}
+
 func writeOutSNAC(originsnac oscar.SnacFrame, snacFrame oscar.SnacFrame, snacOut any, sequence *uint32, w io.Writer) error {
 	if originsnac.RequestID != 0 {
 		snacFrame.RequestID = originsnac.RequestID
@@ -138,43 +183,3 @@ func sendInvalidSNACErr(snac oscar.SnacFrame, w io.Writer, sequence *uint32) err
 	}
 	return writeOutSNAC(snac, snacFrameOut, snacPayloadOut, sequence, w)
 }
-
-type ChatServiceRouter struct {
-	ChatRouter
-	OServiceChatRouter
-	cfg Config
-	RouteLogger
-}
-
-func (rt *ChatServiceRouter) Route(ctx context.Context, sess *state.Session, r io.Reader, w io.Writer, sequence *uint32, chatID string) error {
-	snac := oscar.SnacFrame{}
-	if err := oscar.Unmarshal(&snac, r); err != nil {
-		return err
-	}
-
-	err := func() error {
-		switch snac.FoodGroup {
-		case oscar.OSERVICE:
-			return rt.RouteOService(ctx, sess, chatID, snac, r, w, sequence)
-		case oscar.CHAT:
-			return rt.RouteChat(ctx, sess, chatID, snac, r, w, sequence)
-		default:
-			return ErrUnsupportedSubGroup
-		}
-	}()
-
-	if err != nil {
-		rt.logRequestError(ctx, snac, err)
-		if errors.Is(err, ErrUnsupportedSubGroup) {
-			if err1 := sendInvalidSNACErr(snac, w, sequence); err1 != nil {
-				err = errors.Join(err1, err)
-			}
-			if rt.cfg.FailFast {
-				panic(err.Error())
-			}
-			return nil
-		}
-	}
-
-	return err
-}

state/chat_registry.go

@@ -2,9 +2,10 @@ package state
 
 import (
 	"errors"
-	"github.com/mkaminski/goaim/oscar"
 	"sync"
 	"time"
+
+	"github.com/mkaminski/goaim/oscar"
 )
 
 type ChatRegistry struct {