merge user types back into server package

cmd/main.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"fmt"
-	"github.com/mkaminski/goaim/user"
 	"os"
 	"sync"
 
@@ -18,14 +17,14 @@ func main() {
 		os.Exit(1)
 	}
 
-	fm, err := user.NewSQLiteFeedbagStore(cfg.DBPath)
+	fm, err := server.NewSQLiteFeedbagStore(cfg.DBPath)
 	if err != nil {
 		_, _ = fmt.Fprintf(os.Stderr, "unable to create feedbag store: %s", err.Error())
 		os.Exit(1)
 	}
 
 	logger := server.NewLogger(cfg)
-	sm := user.NewSessionManager(logger)
+	sm := server.NewSessionManager(logger)
 	cr := server.NewChatRegistry()
 
 	wg := sync.WaitGroup{}

server/bucp.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/mkaminski/goaim/user"
 	"io"
 
 	"github.com/google/uuid"
@@ -28,7 +27,7 @@ func routeBUCP(context.Context) error {
 	return ErrUnsupportedSubGroup
 }
 
-func ReceiveAndSendAuthChallenge(cfg Config, fm *user.SQLiteFeedbagStore, r io.Reader, w io.Writer, sequence *uint32, newUUID func() uuid.UUID) error {
+func ReceiveAndSendAuthChallenge(cfg Config, fm *SQLiteFeedbagStore, r io.Reader, w io.Writer, sequence *uint32, newUUID func() uuid.UUID) error {
 	flap := oscar.FlapFrame{}
 	if err := oscar.Unmarshal(&flap, r); err != nil {
 		return err
@@ -85,7 +84,7 @@ func ReceiveAndSendAuthChallenge(cfg Config, fm *user.SQLiteFeedbagStore, r io.R
 	return writeOutSNAC(snac, snacFrameOut, snacPayloadOut, sequence, w)
 }
 
-func ReceiveAndSendBUCPLoginRequest(cfg Config, sm SessionManager, fm *user.SQLiteFeedbagStore, r io.Reader, w io.Writer, sequence *uint32, newUUID func() uuid.UUID) error {
+func ReceiveAndSendBUCPLoginRequest(cfg Config, sm SessionManager, fm *SQLiteFeedbagStore, r io.Reader, w io.Writer, sequence *uint32, newUUID func() uuid.UUID) error {
 	flap := oscar.FlapFrame{}
 	if err := oscar.Unmarshal(&flap, r); err != nil {
 		return err
@@ -124,7 +123,7 @@ func ReceiveAndSendBUCPLoginRequest(cfg Config, sm SessionManager, fm *user.SQLi
 		loginOK = true
 	case cfg.DisableAuth:
 		// login failed but let them in anyway
-		newUser, err := user.NewStubUser(screenName)
+		newUser, err := NewStubUser(screenName)
 		if err != nil {
 			return err
 		}
@@ -192,7 +191,7 @@ func SendAndReceiveSignonFrame(rw io.ReadWriter, sequence *uint32) (oscar.FlapSi
 	return flapSignonFrameIn, nil
 }
 
-func VerifyLogin(sm SessionManager, rw io.ReadWriter) (*user.Session, uint32, error) {
+func VerifyLogin(sm SessionManager, rw io.ReadWriter) (*Session, uint32, error) {
 	seq := uint32(100)
 
 	flap, err := SendAndReceiveSignonFrame(rw, &seq)

server/bucp_test.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"bytes"
-	"github.com/mkaminski/goaim/user"
 	"os"
 	"testing"
 
@@ -12,7 +11,7 @@ import (
 )
 
 func TestReceiveAndSendBUCPLoginRequest(t *testing.T) {
-	userGoodPwd := user.User{
+	userGoodPwd := User{
 		ScreenName: "sn_user_a",
 		AuthKey:    "auth_key_user",
 	}
@@ -23,7 +22,7 @@ func TestReceiveAndSendBUCPLoginRequest(t *testing.T) {
 	cases := []struct {
 		name            string
 		cfg             Config
-		userInDB        user.User
+		userInDB        User
 		sessionUUID     uuid.UUID
 		inputSNAC       oscar.SNAC_0x17_0x02_BUCPLoginRequest
 		expectSnacFrame oscar.SnacFrame
@@ -130,12 +129,12 @@ func TestReceiveAndSendBUCPLoginRequest(t *testing.T) {
 			defer func() {
 				assert.NoError(t, os.Remove(testFile))
 			}()
-			fs, err := user.NewSQLiteFeedbagStore(testFile)
+			fs, err := NewSQLiteFeedbagStore(testFile)
 			if err != nil {
 				assert.NoError(t, err)
 			}
 			assert.NoError(t, fs.InsertUser(tc.userInDB))
-			sm := user.NewSessionManager(NewLogger(Config{}))
+			sm := NewSessionManager(NewLogger(Config{}))
 			//
 			// send input SNAC
 			//
@@ -173,7 +172,7 @@ func TestReceiveAndSendAuthChallenge(t *testing.T) {
 	cases := []struct {
 		name            string
 		cfg             Config
-		userInDB        user.User
+		userInDB        User
 		fnNewUUID       uuid.UUID
 		inputSNAC       oscar.SNAC_0x17_0x06_BUCPChallengeRequest
 		expectSnacFrame oscar.SnacFrame
@@ -185,7 +184,7 @@ func TestReceiveAndSendAuthChallenge(t *testing.T) {
 				OSCARHost: "127.0.0.1",
 				BOSPort:   1234,
 			},
-			userInDB: user.User{
+			userInDB: User{
 				ScreenName: "sn_user_a",
 				AuthKey:    "auth_key_user_a",
 			},
@@ -212,7 +211,7 @@ func TestReceiveAndSendAuthChallenge(t *testing.T) {
 				BOSPort:     1234,
 				DisableAuth: true,
 			},
-			userInDB: user.User{
+			userInDB: User{
 				ScreenName: "sn_user_a",
 				AuthKey:    "auth_key_user_a",
 			},
@@ -238,7 +237,7 @@ func TestReceiveAndSendAuthChallenge(t *testing.T) {
 				OSCARHost: "127.0.0.1",
 				BOSPort:   1234,
 			},
-			userInDB: user.User{
+			userInDB: User{
 				ScreenName: "sn_user_a",
 				AuthKey:    "auth_key_user_a",
 			},
@@ -273,7 +272,7 @@ func TestReceiveAndSendAuthChallenge(t *testing.T) {
 			defer func() {
 				assert.NoError(t, os.Remove(testFile))
 			}()
-			fs, err := user.NewSQLiteFeedbagStore(testFile)
+			fs, err := NewSQLiteFeedbagStore(testFile)
 			if err != nil {
 				assert.NoError(t, err)
 			}

server/buddy.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"github.com/mkaminski/goaim/user"
 	"io"
 	"log/slog"
 
@@ -64,7 +63,7 @@ func (s BuddyService) RightsQueryHandler(context.Context) oscar.XMessage {
 	}
 }
 
-func BroadcastArrival(ctx context.Context, sess *user.Session, sm SessionManager, fm FeedbagManager) error {
+func BroadcastArrival(ctx context.Context, sess *Session, sm SessionManager, fm FeedbagManager) error {
 	screenNames, err := fm.InterestedUsers(sess.ScreenName())
 	if err != nil {
 		return err
@@ -89,7 +88,7 @@ func BroadcastArrival(ctx context.Context, sess *user.Session, sm SessionManager
 	return nil
 }
 
-func BroadcastDeparture(ctx context.Context, sess *user.Session, sm SessionManager, fm FeedbagManager) error {
+func BroadcastDeparture(ctx context.Context, sess *Session, sm SessionManager, fm FeedbagManager) error {
 	screenNames, err := fm.InterestedUsers(sess.ScreenName())
 	if err != nil {
 		return err

server/chat.go

@@ -2,15 +2,17 @@ package server
 
 import (
 	"context"
-	"github.com/mkaminski/goaim/user"
+	"errors"
 	"io"
 	"log/slog"
+	"sync"
+	"time"
 
 	"github.com/mkaminski/goaim/oscar"
 )
 
 type ChatHandler interface {
-	ChannelMsgToHostHandler(ctx context.Context, sess *user.Session, room ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error)
+	ChannelMsgToHostHandler(ctx context.Context, sess *Session, room ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error)
 }
 
 func NewChatRouter(logger *slog.Logger) ChatRouter {
@@ -27,7 +29,7 @@ type ChatRouter struct {
 	RouteLogger
 }
 
-func (rt *ChatRouter) RouteChat(ctx context.Context, sess *user.Session, chatSessMgr ChatSessionManager, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt *ChatRouter) RouteChat(ctx context.Context, sess *Session, chatSessMgr ChatSessionManager, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
 	switch SNACFrame.SubGroup {
 	case oscar.ChatChannelMsgToHost:
 		inSNAC := oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost{}
@@ -52,7 +54,7 @@ func (rt *ChatRouter) RouteChat(ctx context.Context, sess *user.Session, chatSes
 type ChatService struct {
 }
 
-func (s ChatService) ChannelMsgToHostHandler(ctx context.Context, sess *user.Session, chatSessMgr ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error) {
+func (s ChatService) ChannelMsgToHostHandler(ctx context.Context, sess *Session, chatSessMgr ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error) {
 	snacFrameOut := oscar.SnacFrame{
 		FoodGroup: oscar.CHAT,
 		SubGroup:  oscar.ChatChannelMsgToClient,
@@ -92,7 +94,7 @@ func (s ChatService) ChannelMsgToHostHandler(ctx context.Context, sess *user.Ses
 	return ret, nil
 }
 
-func SetOnlineChatUsers(ctx context.Context, sess *user.Session, chatSessMgr ChatSessionManager) {
+func SetOnlineChatUsers(ctx context.Context, sess *Session, chatSessMgr ChatSessionManager) {
 	snacPayloadOut := oscar.SNAC_0x0E_0x03_ChatUsersJoined{}
 	sessions := chatSessMgr.Participants()
 
@@ -115,7 +117,7 @@ func SetOnlineChatUsers(ctx context.Context, sess *user.Session, chatSessMgr Cha
 	})
 }
 
-func AlertUserJoined(ctx context.Context, sess *user.Session, chatSessMgr ChatSessionManager) {
+func AlertUserJoined(ctx context.Context, sess *Session, chatSessMgr ChatSessionManager) {
 	chatSessMgr.BroadcastExcept(ctx, sess, oscar.XMessage{
 		SnacFrame: oscar.SnacFrame{
 			FoodGroup: oscar.CHAT,
@@ -135,7 +137,7 @@ func AlertUserJoined(ctx context.Context, sess *user.Session, chatSessMgr ChatSe
 	})
 }
 
-func AlertUserLeft(ctx context.Context, sess *user.Session, chatSessMgr ChatSessionManager) {
+func AlertUserLeft(ctx context.Context, sess *Session, chatSessMgr ChatSessionManager) {
 	chatSessMgr.BroadcastExcept(ctx, sess, oscar.XMessage{
 		SnacFrame: oscar.SnacFrame{
 			FoodGroup: oscar.CHAT,
@@ -155,7 +157,7 @@ func AlertUserLeft(ctx context.Context, sess *user.Session, chatSessMgr ChatSess
 	})
 }
 
-func SendChatRoomInfoUpdate(ctx context.Context, sess *user.Session, chatSessMgr ChatSessionManager, room ChatRoom) {
+func SendChatRoomInfoUpdate(ctx context.Context, sess *Session, chatSessMgr ChatSessionManager, room ChatRoom) {
 	chatSessMgr.SendToScreenName(ctx, sess.ScreenName(), oscar.XMessage{
 		SnacFrame: oscar.SnacFrame{
 			FoodGroup: oscar.CHAT,
@@ -172,3 +174,68 @@ func SendChatRoomInfoUpdate(ctx context.Context, sess *user.Session, chatSessMgr
 		},
 	})
 }
+
+type ChatRoom struct {
+	CreateTime     time.Time
+	DetailLevel    uint8
+	Exchange       uint16
+	Cookie         string
+	InstanceNumber uint16
+	Name           string
+}
+
+func (c ChatRoom) TLVList() []oscar.TLV {
+	return []oscar.TLV{
+		oscar.NewTLV(0x00c9, uint16(15)),
+		oscar.NewTLV(0x00ca, uint32(c.CreateTime.Unix())),
+		oscar.NewTLV(0x00d1, uint16(1024)),
+		oscar.NewTLV(0x00d2, uint16(100)),
+		oscar.NewTLV(0x00d5, uint8(2)),
+		oscar.NewTLV(0x006a, c.Name),
+		oscar.NewTLV(0x00d3, c.Name),
+	}
+}
+
+type ChatRegistry struct {
+	chatRoomStore map[string]ChatRoom
+	smStore       map[string]ChatSessionManager
+	mapMutex      sync.RWMutex
+}
+
+func NewChatRegistry() *ChatRegistry {
+	return &ChatRegistry{
+		chatRoomStore: make(map[string]ChatRoom),
+		smStore:       make(map[string]ChatSessionManager),
+	}
+}
+
+func (c *ChatRegistry) Register(room ChatRoom, sm ChatSessionManager) {
+	c.mapMutex.Lock()
+	defer c.mapMutex.Unlock()
+	c.chatRoomStore[room.Cookie] = room
+	c.smStore[room.Cookie] = sm
+}
+
+func (c *ChatRegistry) Retrieve(chatID string) (ChatRoom, ChatSessionManager, error) {
+	c.mapMutex.RLock()
+	defer c.mapMutex.RUnlock()
+	cr, found := c.chatRoomStore[chatID]
+	if !found {
+		return ChatRoom{}, nil, errors.New("unable to find chat room")
+	}
+	sm, found := c.smStore[chatID]
+	if !found {
+		panic("unable to find session manager for chat")
+	}
+	return cr, sm, nil
+}
+
+func (c *ChatRegistry) MaybeRemoveRoom(chatID string) {
+	c.mapMutex.Lock()
+	defer c.mapMutex.Unlock()
+	sm, found := c.smStore[chatID]
+	if found && sm.Empty() {
+		delete(c.chatRoomStore, chatID)
+		delete(c.smStore, chatID)
+	}
+}

server/chat_mock.go

@@ -7,8 +7,6 @@ import (
 
 	oscar "github.com/mkaminski/goaim/oscar"
 	mock "github.com/stretchr/testify/mock"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockChatHandler is an autogenerated mock type for the ChatHandler type
@@ -25,15 +23,15 @@ func (_m *MockChatHandler) EXPECT() *MockChatHandler_Expecter {
 }
 
 // ChannelMsgToHostHandler provides a mock function with given fields: ctx, sess, room, snacPayloadIn
-func (_m *MockChatHandler) ChannelMsgToHostHandler(ctx context.Context, sess *user.Session, room ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error) {
+func (_m *MockChatHandler) ChannelMsgToHostHandler(ctx context.Context, sess *Session, room ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, room, snacPayloadIn)
 
 	var r0 *oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, ChatSessionManager, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, ChatSessionManager, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error)); ok {
 		return rf(ctx, sess, room, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, ChatSessionManager, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) *oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, ChatSessionManager, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) *oscar.XMessage); ok {
 		r0 = rf(ctx, sess, room, snacPayloadIn)
 	} else {
 		if ret.Get(0) != nil {
@@ -41,7 +39,7 @@ func (_m *MockChatHandler) ChannelMsgToHostHandler(ctx context.Context, sess *us
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, ChatSessionManager, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, ChatSessionManager, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) error); ok {
 		r1 = rf(ctx, sess, room, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -57,16 +55,16 @@ type MockChatHandler_ChannelMsgToHostHandler_Call struct {
 
 // ChannelMsgToHostHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *Session
 //   - room ChatSessionManager
 //   - snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost
 func (_e *MockChatHandler_Expecter) ChannelMsgToHostHandler(ctx interface{}, sess interface{}, room interface{}, snacPayloadIn interface{}) *MockChatHandler_ChannelMsgToHostHandler_Call {
 	return &MockChatHandler_ChannelMsgToHostHandler_Call{Call: _e.mock.On("ChannelMsgToHostHandler", ctx, sess, room, snacPayloadIn)}
 }
 
-func (_c *MockChatHandler_ChannelMsgToHostHandler_Call) Run(run func(ctx context.Context, sess *user.Session, room ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost)) *MockChatHandler_ChannelMsgToHostHandler_Call {
+func (_c *MockChatHandler_ChannelMsgToHostHandler_Call) Run(run func(ctx context.Context, sess *Session, room ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost)) *MockChatHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(ChatSessionManager), args[3].(oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(ChatSessionManager), args[3].(oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost))
 	})
 	return _c
 }
@@ -76,7 +74,7 @@ func (_c *MockChatHandler_ChannelMsgToHostHandler_Call) Return(_a0 *oscar.XMessa
 	return _c
 }
 
-func (_c *MockChatHandler_ChannelMsgToHostHandler_Call) RunAndReturn(run func(context.Context, *user.Session, ChatSessionManager, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error)) *MockChatHandler_ChannelMsgToHostHandler_Call {
+func (_c *MockChatHandler_ChannelMsgToHostHandler_Call) RunAndReturn(run func(context.Context, *Session, ChatSessionManager, oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost) (*oscar.XMessage, error)) *MockChatHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/chat_nav.go

@@ -5,14 +5,13 @@ import (
 	"errors"
 	"github.com/google/uuid"
 	"github.com/mkaminski/goaim/oscar"
-	"github.com/mkaminski/goaim/user"
 	"io"
 	"log/slog"
 	"time"
 )
 
 type ChatNavHandler interface {
-	CreateRoomHandler(ctx context.Context, sess *user.Session, newRoom func() ChatRoom, newChatSessMgr func() ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error)
+	CreateRoomHandler(ctx context.Context, sess *Session, newRoom func() ChatRoom, newChatSessMgr func() ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error)
 	RequestChatRightsHandler(ctx context.Context) oscar.XMessage
 	RequestRoomInfoHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x0D_0x04_ChatNavRequestRoomInfo) (oscar.XMessage, error)
 }
@@ -34,7 +33,7 @@ type ChatNavRouter struct {
 	RouteLogger
 }
 
-func (rt *ChatNavRouter) RouteChatNav(ctx context.Context, sess *user.Session, newChatSessMgr func() ChatSessionManager, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt *ChatNavRouter) RouteChatNav(ctx context.Context, sess *Session, newChatSessMgr func() ChatSessionManager, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
 	switch SNACFrame.SubGroup {
 	case oscar.ChatNavRequestChatRights:
 		outSNAC := rt.RequestChatRightsHandler(ctx)
@@ -116,7 +115,7 @@ func (s ChatNavService) RequestChatRightsHandler(context.Context) oscar.XMessage
 	}
 }
 
-func (s ChatNavService) CreateRoomHandler(ctx context.Context, sess *user.Session, newChatRoom func() ChatRoom, newChatSessMgr func() ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error) {
+func (s ChatNavService) CreateRoomHandler(ctx context.Context, sess *Session, newChatRoom func() ChatRoom, newChatSessMgr func() ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error) {
 	name, hasName := snacPayloadIn.GetString(oscar.ChatTLVRoomName)
 	if !hasName {
 		return oscar.XMessage{}, errors.New("unable to find chat name")

server/chat_nav_mock.go

@@ -7,8 +7,6 @@ import (
 
 	oscar "github.com/mkaminski/goaim/oscar"
 	mock "github.com/stretchr/testify/mock"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockChatNavHandler is an autogenerated mock type for the ChatNavHandler type
@@ -25,21 +23,21 @@ func (_m *MockChatNavHandler) EXPECT() *MockChatNavHandler_Expecter {
 }
 
 // CreateRoomHandler provides a mock function with given fields: ctx, sess, newRoom, newChatSessMgr, snacPayloadIn
-func (_m *MockChatNavHandler) CreateRoomHandler(ctx context.Context, sess *user.Session, newRoom func() ChatRoom, newChatSessMgr func() ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error) {
+func (_m *MockChatNavHandler) CreateRoomHandler(ctx context.Context, sess *Session, newRoom func() ChatRoom, newChatSessMgr func() ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, newRoom, newChatSessMgr, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, func() ChatRoom, func() ChatSessionManager, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, func() ChatRoom, func() ChatSessionManager, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, newRoom, newChatSessMgr, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, func() ChatRoom, func() ChatSessionManager, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, func() ChatRoom, func() ChatSessionManager, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, newRoom, newChatSessMgr, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, func() ChatRoom, func() ChatSessionManager, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, func() ChatRoom, func() ChatSessionManager, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) error); ok {
 		r1 = rf(ctx, sess, newRoom, newChatSessMgr, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -55,7 +53,7 @@ type MockChatNavHandler_CreateRoomHandler_Call struct {
 
 // CreateRoomHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *Session
 //   - newRoom func() ChatRoom
 //   - newChatSessMgr func() ChatSessionManager
 //   - snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate
@@ -63,9 +61,9 @@ func (_e *MockChatNavHandler_Expecter) CreateRoomHandler(ctx interface{}, sess i
 	return &MockChatNavHandler_CreateRoomHandler_Call{Call: _e.mock.On("CreateRoomHandler", ctx, sess, newRoom, newChatSessMgr, snacPayloadIn)}
 }
 
-func (_c *MockChatNavHandler_CreateRoomHandler_Call) Run(run func(ctx context.Context, sess *user.Session, newRoom func() ChatRoom, newChatSessMgr func() ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate)) *MockChatNavHandler_CreateRoomHandler_Call {
+func (_c *MockChatNavHandler_CreateRoomHandler_Call) Run(run func(ctx context.Context, sess *Session, newRoom func() ChatRoom, newChatSessMgr func() ChatSessionManager, snacPayloadIn oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate)) *MockChatNavHandler_CreateRoomHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(func() ChatRoom), args[3].(func() ChatSessionManager), args[4].(oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(func() ChatRoom), args[3].(func() ChatSessionManager), args[4].(oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate))
 	})
 	return _c
 }
@@ -75,7 +73,7 @@ func (_c *MockChatNavHandler_CreateRoomHandler_Call) Return(_a0 oscar.XMessage,
 	return _c
 }
 
-func (_c *MockChatNavHandler_CreateRoomHandler_Call) RunAndReturn(run func(context.Context, *user.Session, func() ChatRoom, func() ChatSessionManager, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error)) *MockChatNavHandler_CreateRoomHandler_Call {
+func (_c *MockChatNavHandler_CreateRoomHandler_Call) RunAndReturn(run func(context.Context, *Session, func() ChatRoom, func() ChatSessionManager, oscar.SNAC_0x0E_0x02_ChatRoomInfoUpdate) (oscar.XMessage, error)) *MockChatNavHandler_CreateRoomHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/chat_nav_test.go

@@ -3,7 +3,6 @@ package server
 import (
 	"bytes"
 	"context"
-	"github.com/mkaminski/goaim/user"
 	"testing"
 	"time"
 
@@ -22,7 +21,7 @@ func TestSendAndReceiveCreateRoom(t *testing.T) {
 
 	sm := NewMockChatSessionManager(t)
 	sm.EXPECT().NewSessionWithSN(userSess.ID(), userSess.ScreenName()).
-		Return(&user.Session{})
+		Return(&Session{})
 
 	chatSessMgrFactory := func() ChatSessionManager {
 		return sm

server/chat_session_manager_mock.go

@@ -7,8 +7,6 @@ import (
 
 	oscar "github.com/mkaminski/goaim/oscar"
 	mock "github.com/stretchr/testify/mock"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockChatSessionManager is an autogenerated mock type for the ChatSessionManager type
@@ -59,7 +57,7 @@ func (_c *MockChatSessionManager_Broadcast_Call) RunAndReturn(run func(context.C
 }
 
 // BroadcastExcept provides a mock function with given fields: ctx, except, msg
-func (_m *MockChatSessionManager) BroadcastExcept(ctx context.Context, except *user.Session, msg oscar.XMessage) {
+func (_m *MockChatSessionManager) BroadcastExcept(ctx context.Context, except *Session, msg oscar.XMessage) {
 	_m.Called(ctx, except, msg)
 }
 
@@ -70,15 +68,15 @@ type MockChatSessionManager_BroadcastExcept_Call struct {
 
 // BroadcastExcept is a helper method to define mock.On call
 //   - ctx context.Context
-//   - except *user.Session
+//   - except *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 (_c *MockChatSessionManager_BroadcastExcept_Call) Run(run func(ctx context.Context, except *user.Session, msg oscar.XMessage)) *MockChatSessionManager_BroadcastExcept_Call {
+func (_c *MockChatSessionManager_BroadcastExcept_Call) Run(run func(ctx context.Context, except *Session, msg oscar.XMessage)) *MockChatSessionManager_BroadcastExcept_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.XMessage))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.XMessage))
 	})
 	return _c
 }
@@ -88,7 +86,7 @@ func (_c *MockChatSessionManager_BroadcastExcept_Call) Return() *MockChatSession
 	return _c
 }
 
-func (_c *MockChatSessionManager_BroadcastExcept_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.XMessage)) *MockChatSessionManager_BroadcastExcept_Call {
+func (_c *MockChatSessionManager_BroadcastExcept_Call) RunAndReturn(run func(context.Context, *Session, oscar.XMessage)) *MockChatSessionManager_BroadcastExcept_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -170,15 +168,15 @@ func (_c *MockChatSessionManager_Empty_Call) RunAndReturn(run func() bool) *Mock
 }
 
 // NewSessionWithSN provides a mock function with given fields: sessID, screenName
-func (_m *MockChatSessionManager) NewSessionWithSN(sessID string, screenName string) *user.Session {
+func (_m *MockChatSessionManager) NewSessionWithSN(sessID string, screenName string) *Session {
 	ret := _m.Called(sessID, screenName)
 
-	var r0 *user.Session
-	if rf, ok := ret.Get(0).(func(string, string) *user.Session); ok {
+	var r0 *Session
+	if rf, ok := ret.Get(0).(func(string, string) *Session); ok {
 		r0 = rf(sessID, screenName)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*user.Session)
+			r0 = ret.Get(0).(*Session)
 		}
 	}
 
@@ -204,26 +202,26 @@ func (_c *MockChatSessionManager_NewSessionWithSN_Call) Run(run func(sessID stri
 	return _c
 }
 
-func (_c *MockChatSessionManager_NewSessionWithSN_Call) Return(_a0 *user.Session) *MockChatSessionManager_NewSessionWithSN_Call {
+func (_c *MockChatSessionManager_NewSessionWithSN_Call) Return(_a0 *Session) *MockChatSessionManager_NewSessionWithSN_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockChatSessionManager_NewSessionWithSN_Call) RunAndReturn(run func(string, string) *user.Session) *MockChatSessionManager_NewSessionWithSN_Call {
+func (_c *MockChatSessionManager_NewSessionWithSN_Call) RunAndReturn(run func(string, string) *Session) *MockChatSessionManager_NewSessionWithSN_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Participants provides a mock function with given fields:
-func (_m *MockChatSessionManager) Participants() []*user.Session {
+func (_m *MockChatSessionManager) Participants() []*Session {
 	ret := _m.Called()
 
-	var r0 []*user.Session
-	if rf, ok := ret.Get(0).(func() []*user.Session); ok {
+	var r0 []*Session
+	if rf, ok := ret.Get(0).(func() []*Session); ok {
 		r0 = rf()
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).([]*user.Session)
+			r0 = ret.Get(0).([]*Session)
 		}
 	}
 
@@ -247,18 +245,18 @@ func (_c *MockChatSessionManager_Participants_Call) Run(run func()) *MockChatSes
 	return _c
 }
 
-func (_c *MockChatSessionManager_Participants_Call) Return(_a0 []*user.Session) *MockChatSessionManager_Participants_Call {
+func (_c *MockChatSessionManager_Participants_Call) Return(_a0 []*Session) *MockChatSessionManager_Participants_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockChatSessionManager_Participants_Call) RunAndReturn(run func() []*user.Session) *MockChatSessionManager_Participants_Call {
+func (_c *MockChatSessionManager_Participants_Call) RunAndReturn(run func() []*Session) *MockChatSessionManager_Participants_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Remove provides a mock function with given fields: sess
-func (_m *MockChatSessionManager) Remove(sess *user.Session) {
+func (_m *MockChatSessionManager) Remove(sess *Session) {
 	_m.Called(sess)
 }
 
@@ -268,14 +266,14 @@ type MockChatSessionManager_Remove_Call struct {
 }
 
 // Remove is a helper method to define mock.On call
-//   - sess *user.Session
+//   - sess *Session
 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 *user.Session)) *MockChatSessionManager_Remove_Call {
+func (_c *MockChatSessionManager_Remove_Call) Run(run func(sess *Session)) *MockChatSessionManager_Remove_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*user.Session))
+		run(args[0].(*Session))
 	})
 	return _c
 }
@@ -285,25 +283,25 @@ func (_c *MockChatSessionManager_Remove_Call) Return() *MockChatSessionManager_R
 	return _c
 }
 
-func (_c *MockChatSessionManager_Remove_Call) RunAndReturn(run func(*user.Session)) *MockChatSessionManager_Remove_Call {
+func (_c *MockChatSessionManager_Remove_Call) RunAndReturn(run func(*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) (*user.Session, bool) {
+func (_m *MockChatSessionManager) Retrieve(ID string) (*Session, bool) {
 	ret := _m.Called(ID)
 
-	var r0 *user.Session
+	var r0 *Session
 	var r1 bool
-	if rf, ok := ret.Get(0).(func(string) (*user.Session, bool)); ok {
+	if rf, ok := ret.Get(0).(func(string) (*Session, bool)); ok {
 		return rf(ID)
 	}
-	if rf, ok := ret.Get(0).(func(string) *user.Session); ok {
+	if rf, ok := ret.Get(0).(func(string) *Session); ok {
 		r0 = rf(ID)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*user.Session)
+			r0 = ret.Get(0).(*Session)
 		}
 	}
 
@@ -334,26 +332,26 @@ func (_c *MockChatSessionManager_Retrieve_Call) Run(run func(ID string)) *MockCh
 	return _c
 }
 
-func (_c *MockChatSessionManager_Retrieve_Call) Return(_a0 *user.Session, _a1 bool) *MockChatSessionManager_Retrieve_Call {
+func (_c *MockChatSessionManager_Retrieve_Call) Return(_a0 *Session, _a1 bool) *MockChatSessionManager_Retrieve_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockChatSessionManager_Retrieve_Call) RunAndReturn(run func(string) (*user.Session, bool)) *MockChatSessionManager_Retrieve_Call {
+func (_c *MockChatSessionManager_Retrieve_Call) RunAndReturn(run func(string) (*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) *user.Session {
+func (_m *MockChatSessionManager) RetrieveByScreenName(screenName string) *Session {
 	ret := _m.Called(screenName)
 
-	var r0 *user.Session
-	if rf, ok := ret.Get(0).(func(string) *user.Session); ok {
+	var r0 *Session
+	if rf, ok := ret.Get(0).(func(string) *Session); ok {
 		r0 = rf(screenName)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*user.Session)
+			r0 = ret.Get(0).(*Session)
 		}
 	}
 
@@ -378,12 +376,12 @@ func (_c *MockChatSessionManager_RetrieveByScreenName_Call) Run(run func(screenN
 	return _c
 }
 
-func (_c *MockChatSessionManager_RetrieveByScreenName_Call) Return(_a0 *user.Session) *MockChatSessionManager_RetrieveByScreenName_Call {
+func (_c *MockChatSessionManager_RetrieveByScreenName_Call) Return(_a0 *Session) *MockChatSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockChatSessionManager_RetrieveByScreenName_Call) RunAndReturn(run func(string) *user.Session) *MockChatSessionManager_RetrieveByScreenName_Call {
+func (_c *MockChatSessionManager_RetrieveByScreenName_Call) RunAndReturn(run func(string) *Session) *MockChatSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/chat_test.go

@@ -3,7 +3,6 @@ package server
 import (
 	"bytes"
 	"context"
-	"github.com/mkaminski/goaim/user"
 	"github.com/stretchr/testify/mock"
 	"testing"
 
@@ -16,7 +15,7 @@ func TestSendAndReceiveChatChannelMsgToHost(t *testing.T) {
 		// name is the unit test name
 		name string
 		// userSession is the session of the user sending the chat message
-		userSession *user.Session
+		userSession *Session
 		// inputSNAC is the SNAC sent by the sender client
 		inputSNAC oscar.SNAC_0x0E_0x05_ChatChannelMsgToHost
 		// expectSNACToParticipants is the message the server broadcast to chat

server/connection.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"errors"
-	"github.com/mkaminski/goaim/user"
 	"io"
 	"log"
 	"log/slog"
@@ -52,7 +51,7 @@ func consumeFLAPFrames(r io.Reader, msgCh chan incomingMessage, errCh chan error
 	}
 }
 
-func dispatchIncomingMessages(ctx context.Context, sess *user.Session, seq uint32, rw io.ReadWriter, logger *slog.Logger, fn clientReqHandler, alertHandler alertHandler) {
+func dispatchIncomingMessages(ctx context.Context, sess *Session, seq uint32, rw io.ReadWriter, logger *slog.Logger, fn clientReqHandler, alertHandler alertHandler) {
 	// buffered so that the go routine has room to exit
 	msgCh := make(chan incomingMessage, 1)
 	readErrCh := make(chan error, 1)
@@ -107,8 +106,6 @@ func dispatchIncomingMessages(ctx context.Context, sess *user.Session, seq uint3
 			switch {
 			case errors.Is(io.EOF, err):
 				fallthrough
-			case errors.Is(ErrSignedOff, err):
-				logger.InfoContext(ctx, "client signed off")
 			default:
 				logger.ErrorContext(ctx, "client disconnected with error", "err", err)
 			}
@@ -159,7 +156,7 @@ func HandleChatConnection(ctx context.Context, cr *ChatRegistry, rw io.ReadWrite
 	dispatchIncomingMessages(ctx, chatSess, seq, rw, logger, fnClientReqHandler, fnAlertHandler)
 }
 
-func HandleAuthConnection(cfg Config, sm *user.InMemorySessionManager, fm *user.SQLiteFeedbagStore, conn net.Conn) {
+func HandleAuthConnection(cfg Config, sm *InMemorySessionManager, fm *SQLiteFeedbagStore, conn net.Conn) {
 	defer conn.Close()
 	seq := uint32(100)
 	_, err := SendAndReceiveSignonFrame(conn, &seq)
@@ -262,7 +259,7 @@ func ListenBOS(cfg Config, router BOSServiceRouter, logger *slog.Logger) {
 	}
 }
 
-func ListenBUCPLogin(cfg Config, err error, logger *slog.Logger, sm *user.InMemorySessionManager, fm *user.SQLiteFeedbagStore) {
+func ListenBUCPLogin(cfg Config, err error, logger *slog.Logger, sm *InMemorySessionManager, fm *SQLiteFeedbagStore) {
 	addr := Address("", cfg.OSCARPort)
 	listener, err := net.Listen("tcp", addr)
 	if err != nil {

server/connection_test.go

@@ -5,7 +5,6 @@ import (
 	"bytes"
 	"context"
 	"github.com/mkaminski/goaim/oscar"
-	"github.com/mkaminski/goaim/user"
 	"github.com/stretchr/testify/assert"
 	"io"
 	"sync"
@@ -22,7 +21,7 @@ func TestHandleChatConnection_Notification(t *testing.T) {
 	room := ChatRoom{
 		Name: "test chat room!",
 	}
-	sm := user.NewSessionManager(logger)
+	sm := NewSessionManager(logger)
 	sess := sm.NewSessionWithSN("bob-sess-id", "bob")
 	cr.Register(room, sm)
 
@@ -90,7 +89,7 @@ func TestHandleChatConnection_ClientRequestFLAP(t *testing.T) {
 	room := ChatRoom{
 		Name: "test chat room!",
 	}
-	sm := user.NewSessionManager(logger)
+	sm := NewSessionManager(logger)
 	sess := sm.NewSessionWithSN("bob-sess-id", "bob")
 	cr.Register(room, sm)
 
@@ -150,7 +149,7 @@ func TestHandleChatConnection_SessionClosed(t *testing.T) {
 	room := ChatRoom{
 		Name: "test chat room!",
 	}
-	sm := user.NewSessionManager(logger)
+	sm := NewSessionManager(logger)
 	sess := sm.NewSessionWithSN("bob-sess-id", "bob")
 	cr.Register(room, sm)
 

server/feedbag.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"github.com/mkaminski/goaim/user"
 	"io"
 	"log/slog"
 	"time"
@@ -11,13 +10,13 @@ import (
 )
 
 type FeedbagHandler interface {
-	DeleteItemHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error)
-	InsertItemHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error)
-	QueryHandler(ctx context.Context, sess *user.Session) (oscar.XMessage, error)
-	QueryIfModifiedHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error)
+	DeleteItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error)
+	InsertItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error)
+	QueryHandler(ctx context.Context, sess *Session) (oscar.XMessage, error)
+	QueryIfModifiedHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error)
 	RightsQueryHandler(context.Context) oscar.XMessage
 	StartClusterHandler(context.Context, oscar.SNAC_0x13_0x11_FeedbagStartCluster)
-	UpdateItemHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error)
+	UpdateItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error)
 }
 
 func NewFeedbagRouter(logger *slog.Logger, sm SessionManager, fm FeedbagManager) FeedbagRouter {
@@ -37,7 +36,7 @@ type FeedbagRouter struct {
 	RouteLogger
 }
 
-func (rt FeedbagRouter) RouteFeedbag(ctx context.Context, sess *user.Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt FeedbagRouter) RouteFeedbag(ctx context.Context, sess *Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
 	switch SNACFrame.SubGroup {
 	case oscar.FeedbagRightsQuery:
 		inSNAC := oscar.SNAC_0x13_0x02_FeedbagRightsQuery{}
@@ -170,7 +169,7 @@ func (s FeedbagService) RightsQueryHandler(context.Context) oscar.XMessage {
 	}
 }
 
-func (s FeedbagService) QueryHandler(_ context.Context, sess *user.Session) (oscar.XMessage, error) {
+func (s FeedbagService) QueryHandler(_ context.Context, sess *Session) (oscar.XMessage, error) {
 	fb, err := s.fm.Retrieve(sess.ScreenName())
 	if err != nil {
 		return oscar.XMessage{}, err
@@ -198,7 +197,7 @@ func (s FeedbagService) QueryHandler(_ context.Context, sess *user.Session) (osc
 	}, nil
 }
 
-func (s FeedbagService) QueryIfModifiedHandler(_ context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error) {
+func (s FeedbagService) QueryIfModifiedHandler(_ context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error) {
 	fb, err := s.fm.Retrieve(sess.ScreenName())
 	if err != nil {
 		return oscar.XMessage{}, err
@@ -238,7 +237,7 @@ func (s FeedbagService) QueryIfModifiedHandler(_ context.Context, sess *user.Ses
 	}, nil
 }
 
-func (s FeedbagService) InsertItemHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error) {
+func (s FeedbagService) InsertItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error) {
 	for _, item := range snacPayloadIn.Items {
 		// don't let users block themselves, it causes the AIM client to go
 		// into a weird state.
@@ -285,7 +284,7 @@ func (s FeedbagService) InsertItemHandler(ctx context.Context, sess *user.Sessio
 	}, nil
 }
 
-func (s FeedbagService) UpdateItemHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error) {
+func (s FeedbagService) UpdateItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error) {
 	if err := s.fm.Upsert(sess.ScreenName(), snacPayloadIn.Items); err != nil {
 		return oscar.XMessage{}, nil
 	}
@@ -311,7 +310,7 @@ func (s FeedbagService) UpdateItemHandler(ctx context.Context, sess *user.Sessio
 	}, nil
 }
 
-func (s FeedbagService) DeleteItemHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error) {
+func (s FeedbagService) DeleteItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error) {
 	if err := s.fm.Delete(sess.ScreenName(), snacPayloadIn.Items); err != nil {
 		return oscar.XMessage{}, err
 	}

server/feedbag_manager_mock.go

@@ -7,8 +7,6 @@ import (
 	mock "github.com/stretchr/testify/mock"
 
 	time "time"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockFeedbagManager is an autogenerated mock type for the FeedbagManager type
@@ -25,18 +23,18 @@ func (_m *MockFeedbagManager) EXPECT() *MockFeedbagManager_Expecter {
 }
 
 // Blocked provides a mock function with given fields: sn1, sn2
-func (_m *MockFeedbagManager) Blocked(sn1 string, sn2 string) (user.BlockedState, error) {
+func (_m *MockFeedbagManager) Blocked(sn1 string, sn2 string) (BlockedState, error) {
 	ret := _m.Called(sn1, sn2)
 
-	var r0 user.BlockedState
+	var r0 BlockedState
 	var r1 error
-	if rf, ok := ret.Get(0).(func(string, string) (user.BlockedState, error)); ok {
+	if rf, ok := ret.Get(0).(func(string, string) (BlockedState, error)); ok {
 		return rf(sn1, sn2)
 	}
-	if rf, ok := ret.Get(0).(func(string, string) user.BlockedState); ok {
+	if rf, ok := ret.Get(0).(func(string, string) BlockedState); ok {
 		r0 = rf(sn1, sn2)
 	} else {
-		r0 = ret.Get(0).(user.BlockedState)
+		r0 = ret.Get(0).(BlockedState)
 	}
 
 	if rf, ok := ret.Get(1).(func(string, string) error); ok {
@@ -67,12 +65,12 @@ func (_c *MockFeedbagManager_Blocked_Call) Run(run func(sn1 string, sn2 string))
 	return _c
 }
 
-func (_c *MockFeedbagManager_Blocked_Call) Return(_a0 user.BlockedState, _a1 error) *MockFeedbagManager_Blocked_Call {
+func (_c *MockFeedbagManager_Blocked_Call) Return(_a0 BlockedState, _a1 error) *MockFeedbagManager_Blocked_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockFeedbagManager_Blocked_Call) RunAndReturn(run func(string, string) (user.BlockedState, error)) *MockFeedbagManager_Blocked_Call {
+func (_c *MockFeedbagManager_Blocked_Call) RunAndReturn(run func(string, string) (BlockedState, error)) *MockFeedbagManager_Blocked_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/feedbag_mock.go

@@ -7,8 +7,6 @@ import (
 
 	oscar "github.com/mkaminski/goaim/oscar"
 	mock "github.com/stretchr/testify/mock"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockFeedbagHandler is an autogenerated mock type for the FeedbagHandler type
@@ -25,21 +23,21 @@ func (_m *MockFeedbagHandler) EXPECT() *MockFeedbagHandler_Expecter {
 }
 
 // DeleteItemHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockFeedbagHandler) DeleteItemHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error) {
+func (_m *MockFeedbagHandler) DeleteItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -55,15 +53,15 @@ type MockFeedbagHandler_DeleteItemHandler_Call struct {
 
 // DeleteItemHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockFeedbagHandler_DeleteItemHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem)) *MockFeedbagHandler_DeleteItemHandler_Call {
+func (_c *MockFeedbagHandler_DeleteItemHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x0A_FeedbagDeleteItem)) *MockFeedbagHandler_DeleteItemHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x13_0x0A_FeedbagDeleteItem))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x13_0x0A_FeedbagDeleteItem))
 	})
 	return _c
 }
@@ -73,27 +71,27 @@ func (_c *MockFeedbagHandler_DeleteItemHandler_Call) Return(_a0 oscar.XMessage,
 	return _c
 }
 
-func (_c *MockFeedbagHandler_DeleteItemHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x13_0x0A_FeedbagDeleteItem) (oscar.XMessage, error)) *MockFeedbagHandler_DeleteItemHandler_Call {
+func (_c *MockFeedbagHandler_DeleteItemHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error) {
+func (_m *MockFeedbagHandler) InsertItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -109,15 +107,15 @@ type MockFeedbagHandler_InsertItemHandler_Call struct {
 
 // InsertItemHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockFeedbagHandler_InsertItemHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem)) *MockFeedbagHandler_InsertItemHandler_Call {
+func (_c *MockFeedbagHandler_InsertItemHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x08_FeedbagInsertItem)) *MockFeedbagHandler_InsertItemHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x13_0x08_FeedbagInsertItem))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x13_0x08_FeedbagInsertItem))
 	})
 	return _c
 }
@@ -127,27 +125,27 @@ func (_c *MockFeedbagHandler_InsertItemHandler_Call) Return(_a0 oscar.XMessage,
 	return _c
 }
 
-func (_c *MockFeedbagHandler_InsertItemHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x13_0x08_FeedbagInsertItem) (oscar.XMessage, error)) *MockFeedbagHandler_InsertItemHandler_Call {
+func (_c *MockFeedbagHandler_InsertItemHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session) (oscar.XMessage, error) {
+func (_m *MockFeedbagHandler) QueryHandler(ctx context.Context, sess *Session) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session) oscar.XMessage); ok {
 		r0 = rf(ctx, sess)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session) error); ok {
 		r1 = rf(ctx, sess)
 	} else {
 		r1 = ret.Error(1)
@@ -163,14 +161,14 @@ type MockFeedbagHandler_QueryHandler_Call struct {
 
 // QueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockFeedbagHandler_QueryHandler_Call) Run(run func(ctx context.Context, sess *user.Session)) *MockFeedbagHandler_QueryHandler_Call {
+func (_c *MockFeedbagHandler_QueryHandler_Call) Run(run func(ctx context.Context, sess *Session)) *MockFeedbagHandler_QueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session))
+		run(args[0].(context.Context), args[1].(*Session))
 	})
 	return _c
 }
@@ -180,27 +178,27 @@ func (_c *MockFeedbagHandler_QueryHandler_Call) Return(_a0 oscar.XMessage, _a1 e
 	return _c
 }
 
-func (_c *MockFeedbagHandler_QueryHandler_Call) RunAndReturn(run func(context.Context, *user.Session) (oscar.XMessage, error)) *MockFeedbagHandler_QueryHandler_Call {
+func (_c *MockFeedbagHandler_QueryHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error) {
+func (_m *MockFeedbagHandler) QueryIfModifiedHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -216,15 +214,15 @@ type MockFeedbagHandler_QueryIfModifiedHandler_Call struct {
 
 // QueryIfModifiedHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockFeedbagHandler_QueryIfModifiedHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified)) *MockFeedbagHandler_QueryIfModifiedHandler_Call {
+func (_c *MockFeedbagHandler_QueryIfModifiedHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x05_FeedbagQueryIfModified)) *MockFeedbagHandler_QueryIfModifiedHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x13_0x05_FeedbagQueryIfModified))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x13_0x05_FeedbagQueryIfModified))
 	})
 	return _c
 }
@@ -234,7 +232,7 @@ func (_c *MockFeedbagHandler_QueryIfModifiedHandler_Call) Return(_a0 oscar.XMess
 	return _c
 }
 
-func (_c *MockFeedbagHandler_QueryIfModifiedHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error)) *MockFeedbagHandler_QueryIfModifiedHandler_Call {
+func (_c *MockFeedbagHandler_QueryIfModifiedHandler_Call) RunAndReturn(run func(context.Context, *Session, oscar.SNAC_0x13_0x05_FeedbagQueryIfModified) (oscar.XMessage, error)) *MockFeedbagHandler_QueryIfModifiedHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -316,21 +314,21 @@ func (_c *MockFeedbagHandler_StartClusterHandler_Call) RunAndReturn(run func(con
 }
 
 // UpdateItemHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockFeedbagHandler) UpdateItemHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error) {
+func (_m *MockFeedbagHandler) UpdateItemHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -346,15 +344,15 @@ type MockFeedbagHandler_UpdateItemHandler_Call struct {
 
 // UpdateItemHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockFeedbagHandler_UpdateItemHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem)) *MockFeedbagHandler_UpdateItemHandler_Call {
+func (_c *MockFeedbagHandler_UpdateItemHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x13_0x09_FeedbagUpdateItem)) *MockFeedbagHandler_UpdateItemHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x13_0x09_FeedbagUpdateItem))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x13_0x09_FeedbagUpdateItem))
 	})
 	return _c
 }
@@ -364,7 +362,7 @@ func (_c *MockFeedbagHandler_UpdateItemHandler_Call) Return(_a0 oscar.XMessage,
 	return _c
 }
 
-func (_c *MockFeedbagHandler_UpdateItemHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error)) *MockFeedbagHandler_UpdateItemHandler_Call {
+func (_c *MockFeedbagHandler_UpdateItemHandler_Call) RunAndReturn(run func(context.Context, *Session, oscar.SNAC_0x13_0x09_FeedbagUpdateItem) (oscar.XMessage, error)) *MockFeedbagHandler_UpdateItemHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }

user/feedbag_store.go → server/feedbag_store.go

@@ -1,4 +1,4 @@
-package user
+package server
 
 import (
 	"bytes"

user/feedbag_store_test.go → server/feedbag_store_test.go

@@ -1,4 +1,4 @@
-package user
+package server
 
 import (
 	"os"

server/feedbag_test.go

@@ -3,7 +3,6 @@ package server
 import (
 	"bytes"
 	"github.com/mkaminski/goaim/oscar"
-	"github.com/mkaminski/goaim/user"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"testing"
@@ -232,14 +231,14 @@ func TestInsertItemHandler(t *testing.T) {
 		// name is the unit test name
 		name string
 		// userSession is the session of the user managing buddy list
-		userSession *user.Session
+		userSession *Session
 		// feedbagItems is the list of items in user's buddy list
 		feedbagItems []oscar.FeedbagItem
 		// inputSNAC is the SNAC sent by the sender client
 		inputSNAC oscar.SNAC_0x13_0x08_FeedbagInsertItem
 		// screenNameLookups is the list of user's online buddies
 		screenNameLookups map[string]struct {
-			sess *user.Session
+			sess *Session
 			err  error
 		}
 		// clientResponse is the message returned to the client
@@ -266,7 +265,7 @@ func TestInsertItemHandler(t *testing.T) {
 				},
 			},
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"user_screen_name": {
@@ -340,7 +339,7 @@ func TestInsertItemHandler(t *testing.T) {
 				},
 			},
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"buddy_offline": {
@@ -369,7 +368,7 @@ func TestInsertItemHandler(t *testing.T) {
 				},
 			},
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"invisible_buddy_online": {
@@ -399,7 +398,7 @@ func TestInsertItemHandler(t *testing.T) {
 				},
 			},
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"user_screen_name": {
@@ -466,7 +465,7 @@ func TestInsertItemHandler(t *testing.T) {
 				},
 			},
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"user_screen_name": {

server/icbm.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"github.com/mkaminski/goaim/user"
 	"io"
 	"log/slog"
 
@@ -15,9 +14,9 @@ const (
 )
 
 type ICBMHandler interface {
-	ChannelMsgToHostHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error)
-	ClientEventHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error
-	EvilRequestHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error)
+	ChannelMsgToHostHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error)
+	ClientEventHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error
+	EvilRequestHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error)
 	ParameterQueryHandler(context.Context) oscar.XMessage
 }
 
@@ -38,7 +37,7 @@ type ICBMRouter struct {
 	RouteLogger
 }
 
-func (rt *ICBMRouter) RouteICBM(ctx context.Context, sess *user.Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt *ICBMRouter) RouteICBM(ctx context.Context, sess *Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
 	switch SNACFrame.SubGroup {
 	case oscar.ICBMAddParameters:
 		inSNAC := oscar.SNAC_0x04_0x02_ICBMAddParameters{}
@@ -109,15 +108,15 @@ func (s ICBMService) ParameterQueryHandler(context.Context) oscar.XMessage {
 	}
 }
 
-func (s ICBMService) ChannelMsgToHostHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error) {
+func (s ICBMService) ChannelMsgToHostHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error) {
 	blocked, err := s.fm.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
 	if err != nil {
 		return nil, err
 	}
 
-	if blocked != user.BlockedNo {
+	if blocked != BlockedNo {
 		code := oscar.ErrorCodeNotLoggedOn
-		if blocked == user.BlockedA {
+		if blocked == BlockedA {
 			code = oscar.ErrorCodeInLocalPermitDeny
 		}
 		return &oscar.XMessage{
@@ -192,13 +191,13 @@ func (s ICBMService) ChannelMsgToHostHandler(ctx context.Context, sess *user.Ses
 	}, nil
 }
 
-func (s ICBMService) ClientEventHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error {
+func (s ICBMService) ClientEventHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error {
 	blocked, err := s.fm.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
 
 	switch {
 	case err != nil:
 		return err
-	case blocked != user.BlockedNo:
+	case blocked != BlockedNo:
 		return nil
 	default:
 		s.sm.SendToScreenName(ctx, snacPayloadIn.ScreenName, oscar.XMessage{
@@ -217,7 +216,7 @@ func (s ICBMService) ClientEventHandler(ctx context.Context, sess *user.Session,
 	}
 }
 
-func (s ICBMService) EvilRequestHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error) {
+func (s ICBMService) EvilRequestHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error) {
 	// don't let users warn themselves, it causes the AIM client to go into a
 	// weird state.
 	if snacPayloadIn.ScreenName == sess.ScreenName() {
@@ -236,7 +235,7 @@ func (s ICBMService) EvilRequestHandler(ctx context.Context, sess *user.Session,
 	if err != nil {
 		return oscar.XMessage{}, nil
 	}
-	if blocked != user.BlockedNo {
+	if blocked != BlockedNo {
 		return oscar.XMessage{
 			SnacFrame: oscar.SnacFrame{
 				FoodGroup: oscar.ICBM,

server/icbm_mock.go

@@ -7,8 +7,6 @@ import (
 
 	oscar "github.com/mkaminski/goaim/oscar"
 	mock "github.com/stretchr/testify/mock"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockICBMHandler is an autogenerated mock type for the ICBMHandler type
@@ -25,15 +23,15 @@ func (_m *MockICBMHandler) EXPECT() *MockICBMHandler_Expecter {
 }
 
 // ChannelMsgToHostHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockICBMHandler) ChannelMsgToHostHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error) {
+func (_m *MockICBMHandler) ChannelMsgToHostHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 *oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) *oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) *oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		if ret.Get(0) != nil {
@@ -41,7 +39,7 @@ func (_m *MockICBMHandler) ChannelMsgToHostHandler(ctx context.Context, sess *us
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -57,15 +55,15 @@ type MockICBMHandler_ChannelMsgToHostHandler_Call struct {
 
 // ChannelMsgToHostHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockICBMHandler_ChannelMsgToHostHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost)) *MockICBMHandler_ChannelMsgToHostHandler_Call {
+func (_c *MockICBMHandler_ChannelMsgToHostHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost)) *MockICBMHandler_ChannelMsgToHostHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost))
 	})
 	return _c
 }
@@ -75,17 +73,17 @@ func (_c *MockICBMHandler_ChannelMsgToHostHandler_Call) Return(_a0 *oscar.XMessa
 	return _c
 }
 
-func (_c *MockICBMHandler_ChannelMsgToHostHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost) (*oscar.XMessage, error)) *MockICBMHandler_ChannelMsgToHostHandler_Call {
+func (_c *MockICBMHandler_ChannelMsgToHostHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error {
+func (_m *MockICBMHandler) ClientEventHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x04_0x14_ICBMClientEvent) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x04_0x14_ICBMClientEvent) error); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Error(0)
@@ -101,15 +99,15 @@ type MockICBMHandler_ClientEventHandler_Call struct {
 
 // ClientEventHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockICBMHandler_ClientEventHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent)) *MockICBMHandler_ClientEventHandler_Call {
+func (_c *MockICBMHandler_ClientEventHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x14_ICBMClientEvent)) *MockICBMHandler_ClientEventHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x04_0x14_ICBMClientEvent))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x04_0x14_ICBMClientEvent))
 	})
 	return _c
 }
@@ -119,27 +117,27 @@ func (_c *MockICBMHandler_ClientEventHandler_Call) Return(_a0 error) *MockICBMHa
 	return _c
 }
 
-func (_c *MockICBMHandler_ClientEventHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x04_0x14_ICBMClientEvent) error) *MockICBMHandler_ClientEventHandler_Call {
+func (_c *MockICBMHandler_ClientEventHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error) {
+func (_m *MockICBMHandler) EvilRequestHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -155,15 +153,15 @@ type MockICBMHandler_EvilRequestHandler_Call struct {
 
 // EvilRequestHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockICBMHandler_EvilRequestHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest)) *MockICBMHandler_EvilRequestHandler_Call {
+func (_c *MockICBMHandler_EvilRequestHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x04_0x08_ICBMEvilRequest)) *MockICBMHandler_EvilRequestHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x04_0x08_ICBMEvilRequest))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x04_0x08_ICBMEvilRequest))
 	})
 	return _c
 }
@@ -173,7 +171,7 @@ func (_c *MockICBMHandler_EvilRequestHandler_Call) Return(_a0 oscar.XMessage, _a
 	return _c
 }
 
-func (_c *MockICBMHandler_EvilRequestHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error)) *MockICBMHandler_EvilRequestHandler_Call {
+func (_c *MockICBMHandler_EvilRequestHandler_Call) RunAndReturn(run func(context.Context, *Session, oscar.SNAC_0x04_0x08_ICBMEvilRequest) (oscar.XMessage, error)) *MockICBMHandler_EvilRequestHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/icbm_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/mkaminski/goaim/oscar"
-	"github.com/mkaminski/goaim/user"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 )
@@ -15,12 +14,12 @@ func TestSendAndReceiveChannelMsgTohost(t *testing.T) {
 		// name is the unit test name
 		name string
 		// blockedState is the response to the sender/recipient block check
-		blockedState user.BlockedState
+		blockedState BlockedState
 		// recipRetrieveErr is the error returned by the recipient session
 		// lookup
 		recipRetrieveErr error
-		senderSession    *user.Session
-		recipientSession *user.Session
+		senderSession    *Session
+		recipientSession *Session
 		// inputSNAC is the SNAC sent by the sender client
 		inputSNAC oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost
 		// expectSNACToClient is the SNAC sent from the server to the
@@ -32,7 +31,7 @@ func TestSendAndReceiveChannelMsgTohost(t *testing.T) {
 	}{
 		{
 			name:             "transmit message from sender to recipient, ack message back to sender",
-			blockedState:     user.BlockedNo,
+			blockedState:     BlockedNo,
 			senderSession:    newTestSession("sender-screen-name", sessOptWarning(10)),
 			recipientSession: newTestSession("recipient-screen-name", sessOptWarning(20)),
 			inputSNAC: oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost{
@@ -82,7 +81,7 @@ func TestSendAndReceiveChannelMsgTohost(t *testing.T) {
 		},
 		{
 			name:             "transmit message from sender to recipient, don't ack message back to sender",
-			blockedState:     user.BlockedNo,
+			blockedState:     BlockedNo,
 			senderSession:    newTestSession("sender-screen-name", sessOptWarning(10)),
 			recipientSession: newTestSession("recipient-screen-name", sessOptWarning(20)),
 			inputSNAC: oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost{
@@ -115,7 +114,7 @@ func TestSendAndReceiveChannelMsgTohost(t *testing.T) {
 		},
 		{
 			name:             "don't transmit message from sender to recipient because sender has blocked recipient",
-			blockedState:     user.BlockedA,
+			blockedState:     BlockedA,
 			senderSession:    newTestSession("sender-screen-name", sessOptWarning(10)),
 			recipientSession: newTestSession("recipient-screen-name", sessOptWarning(20)),
 			inputSNAC: oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost{
@@ -141,7 +140,7 @@ func TestSendAndReceiveChannelMsgTohost(t *testing.T) {
 		},
 		{
 			name:             "don't transmit message from sender to recipient because recipient has blocked sender",
-			blockedState:     user.BlockedB,
+			blockedState:     BlockedB,
 			senderSession:    newTestSession("sender-screen-name", sessOptWarning(10)),
 			recipientSession: newTestSession("recipient-screen-name", sessOptWarning(20)),
 			inputSNAC: oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost{
@@ -167,7 +166,7 @@ func TestSendAndReceiveChannelMsgTohost(t *testing.T) {
 		},
 		{
 			name:             "don't transmit message from sender to recipient because recipient doesn't exist",
-			blockedState:     user.BlockedNo,
+			blockedState:     BlockedNo,
 			senderSession:    newTestSession("sender-screen-name", sessOptWarning(10)),
 			recipientSession: nil,
 			inputSNAC: oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost{
@@ -235,7 +234,7 @@ func TestSendAndReceiveClientEvent(t *testing.T) {
 		// name is the unit test name
 		name string
 		// blockedState is the response to the sender/recipient block check
-		blockedState user.BlockedState
+		blockedState BlockedState
 		// senderScreenName is the screen name of the user sending the event
 		senderScreenName string
 		// inputSNAC is the SNAC sent by the sender client
@@ -246,7 +245,7 @@ func TestSendAndReceiveClientEvent(t *testing.T) {
 	}{
 		{
 			name:             "transmit message from sender to recipient",
-			blockedState:     user.BlockedNo,
+			blockedState:     BlockedNo,
 			senderScreenName: "sender-screen-name",
 			inputSNAC: oscar.SNAC_0x04_0x14_ICBMClientEvent{
 				Cookie:     [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
@@ -269,7 +268,7 @@ func TestSendAndReceiveClientEvent(t *testing.T) {
 		},
 		{
 			name:             "don't transmit message from sender to recipient because sender has blocked recipient",
-			blockedState:     user.BlockedA,
+			blockedState:     BlockedA,
 			senderScreenName: "sender-screen-name",
 			inputSNAC: oscar.SNAC_0x04_0x14_ICBMClientEvent{
 				ScreenName: "recipient-screen-name",
@@ -288,7 +287,7 @@ func TestSendAndReceiveClientEvent(t *testing.T) {
 				Return(tc.blockedState, nil).
 				Maybe()
 			sm := NewMockSessionManager(t)
-			if tc.blockedState == user.BlockedNo {
+			if tc.blockedState == BlockedNo {
 				sm.EXPECT().
 					SendToScreenName(mock.Anything, tc.inputSNAC.ScreenName, tc.expectSNACToClient)
 			}
@@ -310,12 +309,12 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 		// name is the unit test name
 		name string
 		// blockedState is the response to the sender/recipient block check
-		blockedState user.BlockedState
+		blockedState BlockedState
 		// recipRetrieveErr is the error returned by the recipient session
 		// lookup
 		recipRetrieveErr error
 		// senderScreenName is the session name of the user sending the IM
-		senderSession *user.Session
+		senderSession *Session
 		// recipientScreenName is the screen name of the user receiving the IM
 		recipientScreenName string
 		// recipientBuddies is a list of the recipient's buddies that get
@@ -332,7 +331,7 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 	}{
 		{
 			name:                "transmit anonymous warning from sender to recipient",
-			blockedState:        user.BlockedNo,
+			blockedState:        BlockedNo,
 			senderSession:       newTestSession("sender-screen-name"),
 			recipientScreenName: "recipient-screen-name",
 			broadcastMessage: oscar.XMessage{
@@ -377,7 +376,7 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 		},
 		{
 			name:                "transmit non-anonymous warning from sender to recipient",
-			blockedState:        user.BlockedNo,
+			blockedState:        BlockedNo,
 			senderSession:       newTestSession("sender-screen-name"),
 			recipientScreenName: "recipient-screen-name",
 			recipientBuddies:    []string{"buddy1", "buddy2"},
@@ -426,7 +425,7 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 		},
 		{
 			name:                "don't transmit non-anonymous warning from sender to recipient because sender has blocked recipient",
-			blockedState:        user.BlockedA,
+			blockedState:        BlockedA,
 			senderSession:       newTestSession("sender-screen-name"),
 			recipientScreenName: "recipient-screen-name",
 			recipientBuddies:    []string{"buddy1", "buddy2"},
@@ -446,7 +445,7 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 		},
 		{
 			name:                "don't transmit non-anonymous warning from sender to recipient because recipient has blocked sender",
-			blockedState:        user.BlockedB,
+			blockedState:        BlockedB,
 			senderSession:       newTestSession("sender-screen-name"),
 			recipientScreenName: "recipient-screen-name",
 			recipientBuddies:    []string{"buddy1", "buddy2"},

server/locate.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"context"
-	"github.com/mkaminski/goaim/user"
 	"io"
 	"log/slog"
 
@@ -12,9 +11,9 @@ import (
 type LocateHandler interface {
 	RightsQueryHandler(ctx context.Context) oscar.XMessage
 	SetDirInfoHandler(ctx context.Context) oscar.XMessage
-	SetInfoHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo) error
+	SetInfoHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo) error
 	SetKeywordInfoHandler(ctx context.Context) oscar.XMessage
-	UserInfoQuery2Handler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error)
+	UserInfoQuery2Handler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error)
 }
 
 func NewLocateRouter(logger *slog.Logger, sm SessionManager, fm FeedbagManager, pm ProfileManager) LocateRouter {
@@ -35,7 +34,7 @@ type LocateRouter struct {
 	RouteLogger
 }
 
-func (rt LocateRouter) RouteLocate(ctx context.Context, sess *user.Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt LocateRouter) RouteLocate(ctx context.Context, sess *Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
 	switch SNACFrame.SubGroup {
 	case oscar.LocateRightsQuery:
 		outSNAC := rt.RightsQueryHandler(ctx)
@@ -110,7 +109,7 @@ func (s LocateService) RightsQueryHandler(context.Context) oscar.XMessage {
 	}
 }
 
-func (s LocateService) SetInfoHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo) error {
+func (s LocateService) SetInfoHandler(ctx context.Context, sess *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 {
@@ -128,12 +127,12 @@ func (s LocateService) SetInfoHandler(ctx context.Context, sess *user.Session, s
 	return nil
 }
 
-func (s LocateService) UserInfoQuery2Handler(_ context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error) {
+func (s LocateService) UserInfoQuery2Handler(_ context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error) {
 	blocked, err := s.fm.Blocked(sess.ScreenName(), snacPayloadIn.ScreenName)
 	switch {
 	case err != nil:
 		return oscar.XMessage{}, err
-	case blocked != user.BlockedNo:
+	case blocked != BlockedNo:
 		return oscar.XMessage{
 			SnacFrame: oscar.SnacFrame{
 				FoodGroup: oscar.LOCATE,

server/locate_mock.go

@@ -7,8 +7,6 @@ import (
 
 	oscar "github.com/mkaminski/goaim/oscar"
 	mock "github.com/stretchr/testify/mock"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockLocateHandler is an autogenerated mock type for the LocateHandler type
@@ -109,11 +107,11 @@ func (_c *MockLocateHandler_SetDirInfoHandler_Call) RunAndReturn(run func(contex
 }
 
 // SetInfoHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockLocateHandler) SetInfoHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo) error {
+func (_m *MockLocateHandler) SetInfoHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x02_0x04_LocateSetInfo) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x02_0x04_LocateSetInfo) error); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Error(0)
@@ -129,15 +127,15 @@ type MockLocateHandler_SetInfoHandler_Call struct {
 
 // SetInfoHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockLocateHandler_SetInfoHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo)) *MockLocateHandler_SetInfoHandler_Call {
+func (_c *MockLocateHandler_SetInfoHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x02_0x04_LocateSetInfo)) *MockLocateHandler_SetInfoHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x02_0x04_LocateSetInfo))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x02_0x04_LocateSetInfo))
 	})
 	return _c
 }
@@ -147,7 +145,7 @@ func (_c *MockLocateHandler_SetInfoHandler_Call) Return(_a0 error) *MockLocateHa
 	return _c
 }
 
-func (_c *MockLocateHandler_SetInfoHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x02_0x04_LocateSetInfo) error) *MockLocateHandler_SetInfoHandler_Call {
+func (_c *MockLocateHandler_SetInfoHandler_Call) RunAndReturn(run func(context.Context, *Session, oscar.SNAC_0x02_0x04_LocateSetInfo) error) *MockLocateHandler_SetInfoHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -195,21 +193,21 @@ func (_c *MockLocateHandler_SetKeywordInfoHandler_Call) RunAndReturn(run func(co
 }
 
 // UserInfoQuery2Handler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockLocateHandler) UserInfoQuery2Handler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error) {
+func (_m *MockLocateHandler) UserInfoQuery2Handler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -225,15 +223,15 @@ type MockLocateHandler_UserInfoQuery2Handler_Call struct {
 
 // UserInfoQuery2Handler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockLocateHandler_UserInfoQuery2Handler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2)) *MockLocateHandler_UserInfoQuery2Handler_Call {
+func (_c *MockLocateHandler_UserInfoQuery2Handler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x02_0x15_LocateUserInfoQuery2)) *MockLocateHandler_UserInfoQuery2Handler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x02_0x15_LocateUserInfoQuery2))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x02_0x15_LocateUserInfoQuery2))
 	})
 	return _c
 }
@@ -243,7 +241,7 @@ func (_c *MockLocateHandler_UserInfoQuery2Handler_Call) Return(_a0 oscar.XMessag
 	return _c
 }
 
-func (_c *MockLocateHandler_UserInfoQuery2Handler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error)) *MockLocateHandler_UserInfoQuery2Handler_Call {
+func (_c *MockLocateHandler_UserInfoQuery2Handler_Call) RunAndReturn(run func(context.Context, *Session, oscar.SNAC_0x02_0x15_LocateUserInfoQuery2) (oscar.XMessage, error)) *MockLocateHandler_UserInfoQuery2Handler_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/locate_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"github.com/mkaminski/goaim/oscar"
-	"github.com/mkaminski/goaim/user"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"testing"
@@ -15,10 +14,10 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 		// name is the unit test name
 		name string
 		// blockedState is the response to the sender/recipient block check
-		blockedState user.BlockedState
+		blockedState BlockedState
 		// screenNameLookups is the list of user session lookups
 		screenNameLookups map[string]struct {
-			sess *user.Session
+			sess *Session
 			err  error
 		}
 		// screenNameLookups is the list of user session lookups
@@ -27,16 +26,16 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 			err     error
 		}
 		// userSession is the session of the user requesting the user info
-		userSession *user.Session
+		userSession *Session
 		// inputSNAC is the SNAC sent by the sender client
 		inputSNAC    oscar.SNAC_0x02_0x15_LocateUserInfoQuery2
 		expectOutput oscar.XMessage
 	}{
 		{
 			name:         "request user info, expect user info response",
-			blockedState: user.BlockedNo,
+			blockedState: BlockedNo,
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"requested-user": {
@@ -66,9 +65,9 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 		},
 		{
 			name:         "request user info + profile, expect user info response + profile",
-			blockedState: user.BlockedNo,
+			blockedState: BlockedNo,
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"requested-user": {
@@ -112,9 +111,9 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 		},
 		{
 			name:         "request user info + profile, expect user info response + profile",
-			blockedState: user.BlockedNo,
+			blockedState: BlockedNo,
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"requested-user": {
@@ -158,9 +157,9 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 		},
 		{
 			name:         "request user info + away message, expect user info response + away message",
-			blockedState: user.BlockedNo,
+			blockedState: BlockedNo,
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"requested-user": {
@@ -196,7 +195,7 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 		},
 		{
 			name:         "request user info of user who blocked requester, expect not logged in error",
-			blockedState: user.BlockedB,
+			blockedState: BlockedB,
 			userSession:  newTestSession("user_screen_name"),
 			inputSNAC: oscar.SNAC_0x02_0x15_LocateUserInfoQuery2{
 				ScreenName: "requested-user",
@@ -213,9 +212,9 @@ func TestSendAndReceiveUserInfoQuery2(t *testing.T) {
 		},
 		{
 			name:         "request user info of user who does not exist, expect not logged in error",
-			blockedState: user.BlockedNo,
+			blockedState: BlockedNo,
 			screenNameLookups: map[string]struct {
-				sess *user.Session
+				sess *Session
 				err  error
 			}{
 				"non_existent_requested_user": {

server/mgmt_api.go

@@ -3,7 +3,6 @@ package server
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/mkaminski/goaim/user"
 	"log/slog"
 	"net"
 	"net/http"
@@ -12,7 +11,7 @@ import (
 	"github.com/google/uuid"
 )
 
-func StartManagementAPI(fs *user.SQLiteFeedbagStore, logger *slog.Logger) {
+func StartManagementAPI(fs *SQLiteFeedbagStore, logger *slog.Logger) {
 	http.HandleFunc("/user", func(w http.ResponseWriter, r *http.Request) {
 		switch r.Method {
 		case http.MethodGet:
@@ -38,7 +37,7 @@ func StartManagementAPI(fs *user.SQLiteFeedbagStore, logger *slog.Logger) {
 }
 
 // getUsers handles the GET /user endpoint.
-func getUsers(fs *user.SQLiteFeedbagStore, w http.ResponseWriter, r *http.Request) {
+func getUsers(fs *SQLiteFeedbagStore, w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 	users, err := fs.Users()
 	if err != nil {
@@ -52,12 +51,12 @@ func getUsers(fs *user.SQLiteFeedbagStore, w http.ResponseWriter, r *http.Reques
 }
 
 type CreateUser struct {
-	user.User
+	User
 	Password string `json:"password,omitempty"`
 }
 
 // createUser handles the POST /user endpoint.
-func createUser(fs *user.SQLiteFeedbagStore, w http.ResponseWriter, r *http.Request) {
+func createUser(fs *SQLiteFeedbagStore, w http.ResponseWriter, r *http.Request) {
 	var newUser CreateUser
 	if err := json.NewDecoder(r.Body).Decode(&newUser); err != nil {
 		http.Error(w, err.Error(), http.StatusBadRequest)

server/oservice.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"github.com/mkaminski/goaim/oscar"
-	"github.com/mkaminski/goaim/user"
 	"io"
 	"log/slog"
 	"time"
@@ -14,25 +13,25 @@ import (
 
 type OServiceHandler interface {
 	ClientVersionsHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x17_OServiceClientVersions) oscar.XMessage
-	IdleNotificationHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error
+	IdleNotificationHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error
 	RateParamsQueryHandler(ctx context.Context) oscar.XMessage
 	RateParamsSubAddHandler(context.Context, oscar.SNAC_0x01_0x08_OServiceRateParamsSubAdd)
-	SetUserInfoFieldsHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)
-	UserInfoQueryHandler(ctx context.Context, sess *user.Session) oscar.XMessage
+	SetUserInfoFieldsHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)
+	UserInfoQueryHandler(ctx context.Context, sess *Session) oscar.XMessage
 }
 
 type OServiceBOSHandler interface {
 	OServiceHandler
 	WriteOServiceHostOnline(w io.Writer, sequence *uint32) error
-	ServiceRequestHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)
-	ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *user.Session) error
+	ServiceRequestHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)
+	ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *Session) error
 }
 
 type OServiceChatHandler interface {
 	OServiceHandler
 	WriteOServiceHostOnline(w io.Writer, sequence *uint32) error
-	ServiceRequestHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)
-	ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *user.Session, chatSessMgr ChatSessionManager, room ChatRoom) error
+	ServiceRequestHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)
+	ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *Session, chatSessMgr ChatSessionManager, room ChatRoom) error
 }
 
 type OServiceRouter struct {
@@ -40,7 +39,7 @@ type OServiceRouter struct {
 	RouteLogger
 }
 
-func (rt OServiceRouter) RouteOService(ctx context.Context, sess *user.Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt OServiceRouter) RouteOService(ctx context.Context, sess *Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
 	switch SNACFrame.SubGroup {
 	case oscar.OServiceRateParamsQuery:
 		outSNAC := rt.RateParamsQueryHandler(ctx)
@@ -114,7 +113,7 @@ type OServiceBOSRouter struct {
 	OServiceBOSHandler
 }
 
-func (rt OServiceBOSRouter) RouteOService(ctx context.Context, sess *user.Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt OServiceBOSRouter) RouteOService(ctx context.Context, sess *Session, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
 	switch SNACFrame.SubGroup {
 	case oscar.OServiceServiceRequest:
 		inSNAC := oscar.SNAC_0x01_0x04_OServiceServiceRequest{}
@@ -148,7 +147,7 @@ type OServiceChatRouter struct {
 	OServiceChatHandler
 }
 
-func (rt OServiceChatRouter) RouteOService(ctx context.Context, sess *user.Session, chatSessMgr ChatSessionManager, room ChatRoom, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt OServiceChatRouter) RouteOService(ctx context.Context, sess *Session, chatSessMgr ChatSessionManager, room ChatRoom, SNACFrame oscar.SnacFrame, r io.Reader, w io.Writer, sequence *uint32) error {
 	switch SNACFrame.SubGroup {
 	case oscar.OServiceServiceRequest:
 		inSNAC := oscar.SNAC_0x01_0x04_OServiceServiceRequest{}
@@ -262,7 +261,7 @@ func (s OServiceService) RateParamsQueryHandler(_ context.Context) oscar.XMessag
 	}
 }
 
-func (s OServiceService) UserInfoQueryHandler(_ context.Context, sess *user.Session) oscar.XMessage {
+func (s OServiceService) UserInfoQueryHandler(_ context.Context, sess *Session) oscar.XMessage {
 	return oscar.XMessage{
 		SnacFrame: oscar.SnacFrame{
 			FoodGroup: oscar.OSERVICE,
@@ -274,7 +273,7 @@ func (s OServiceService) UserInfoQueryHandler(_ context.Context, sess *user.Sess
 	}
 }
 
-func (s OServiceService) SetUserInfoFieldsHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
+func (s OServiceService) SetUserInfoFieldsHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
 	if status, hasStatus := snacPayloadIn.GetUint32(0x06); hasStatus {
 		switch status {
 		case 0x000:
@@ -302,7 +301,7 @@ func (s OServiceService) SetUserInfoFieldsHandler(ctx context.Context, sess *use
 	}, nil
 }
 
-func (s OServiceService) IdleNotificationHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
+func (s OServiceService) IdleNotificationHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
 	if snacPayloadIn.IdleTime == 0 {
 		sess.SetActive()
 	} else {
@@ -321,7 +320,7 @@ type OServiceServiceForBOS struct {
 	cr *ChatRegistry
 }
 
-func (s OServiceServiceForBOS) ServiceRequestHandler(_ context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
+func (s OServiceServiceForBOS) ServiceRequestHandler(_ context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
 	if snacPayloadIn.FoodGroup != oscar.CHAT {
 		return oscar.XMessage{}, ErrUnsupportedSubGroup
 	}
@@ -383,7 +382,7 @@ func (s OServiceServiceForBOS) WriteOServiceHostOnline(w io.Writer, sequence *ui
 	return writeOutSNAC(oscar.SnacFrame{}, snacFrameOut, snacPayloadOut, sequence, w)
 }
 
-func (s OServiceServiceForBOS) ClientOnlineHandler(ctx context.Context, _ oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *user.Session) error {
+func (s OServiceServiceForBOS) ClientOnlineHandler(ctx context.Context, _ oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *Session) error {
 	if err := BroadcastArrival(ctx, sess, s.sm, s.fm); err != nil {
 		return err
 	}
@@ -421,7 +420,7 @@ type OServiceServiceForChat struct {
 	RouteLogger
 }
 
-func (s OServiceServiceForChat) ServiceRequestHandler(_ context.Context, _ *user.Session, _ oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
+func (s OServiceServiceForChat) ServiceRequestHandler(_ context.Context, _ *Session, _ oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
 	return oscar.XMessage{}, ErrUnsupportedSubGroup
 }
 
@@ -436,7 +435,7 @@ func (s OServiceServiceForChat) WriteOServiceHostOnline(w io.Writer, sequence *u
 	return writeOutSNAC(oscar.SnacFrame{}, snacFrameOut, snacPayloadOut, sequence, w)
 }
 
-func (s OServiceServiceForChat) ClientOnlineHandler(ctx context.Context, _ oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *user.Session, chatSessMgr ChatSessionManager, room ChatRoom) error {
+func (s OServiceServiceForChat) ClientOnlineHandler(ctx context.Context, _ oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *Session, chatSessMgr ChatSessionManager, room ChatRoom) error {
 	SendChatRoomInfoUpdate(ctx, sess, chatSessMgr, room)
 	AlertUserJoined(ctx, sess, chatSessMgr)
 	SetOnlineChatUsers(ctx, sess, chatSessMgr)

server/oservice_bos_mock.go

@@ -9,8 +9,6 @@ import (
 	mock "github.com/stretchr/testify/mock"
 
 	oscar "github.com/mkaminski/goaim/oscar"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockOServiceBOSHandler is an autogenerated mock type for the OServiceBOSHandler type
@@ -27,11 +25,11 @@ func (_m *MockOServiceBOSHandler) EXPECT() *MockOServiceBOSHandler_Expecter {
 }
 
 // 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 *user.Session) error {
+func (_m *MockOServiceBOSHandler) ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *Session) error {
 	ret := _m.Called(ctx, snacPayloadIn, sess)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *user.Session) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *Session) error); ok {
 		r0 = rf(ctx, snacPayloadIn, sess)
 	} else {
 		r0 = ret.Error(0)
@@ -48,14 +46,14 @@ type MockOServiceBOSHandler_ClientOnlineHandler_Call struct {
 // ClientOnlineHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceBOSHandler_ClientOnlineHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *user.Session)) *MockOServiceBOSHandler_ClientOnlineHandler_Call {
+func (_c *MockOServiceBOSHandler_ClientOnlineHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *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].(*user.Session))
+		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x02_OServiceClientOnline), args[2].(*Session))
 	})
 	return _c
 }
@@ -65,7 +63,7 @@ func (_c *MockOServiceBOSHandler_ClientOnlineHandler_Call) Return(_a0 error) *Mo
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_ClientOnlineHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *user.Session) error) *MockOServiceBOSHandler_ClientOnlineHandler_Call {
+func (_c *MockOServiceBOSHandler_ClientOnlineHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *Session) error) *MockOServiceBOSHandler_ClientOnlineHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -114,11 +112,11 @@ func (_c *MockOServiceBOSHandler_ClientVersionsHandler_Call) RunAndReturn(run fu
 }
 
 // IdleNotificationHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceBOSHandler) IdleNotificationHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
+func (_m *MockOServiceBOSHandler) IdleNotificationHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Error(0)
@@ -134,15 +132,15 @@ type MockOServiceBOSHandler_IdleNotificationHandler_Call struct {
 
 // IdleNotificationHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceBOSHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceBOSHandler_IdleNotificationHandler_Call {
+func (_c *MockOServiceBOSHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceBOSHandler_IdleNotificationHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
 	})
 	return _c
 }
@@ -152,7 +150,7 @@ func (_c *MockOServiceBOSHandler_IdleNotificationHandler_Call) Return(_a0 error)
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceBOSHandler_IdleNotificationHandler_Call {
+func (_c *MockOServiceBOSHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceBOSHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -234,21 +232,21 @@ func (_c *MockOServiceBOSHandler_RateParamsSubAddHandler_Call) RunAndReturn(run
 }
 
 // ServiceRequestHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceBOSHandler) ServiceRequestHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
+func (_m *MockOServiceBOSHandler) ServiceRequestHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -264,15 +262,15 @@ type MockOServiceBOSHandler_ServiceRequestHandler_Call struct {
 
 // ServiceRequestHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceBOSHandler_ServiceRequestHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest)) *MockOServiceBOSHandler_ServiceRequestHandler_Call {
+func (_c *MockOServiceBOSHandler_ServiceRequestHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest)) *MockOServiceBOSHandler_ServiceRequestHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x01_0x04_OServiceServiceRequest))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x01_0x04_OServiceServiceRequest))
 	})
 	return _c
 }
@@ -282,27 +280,27 @@ func (_c *MockOServiceBOSHandler_ServiceRequestHandler_Call) Return(_a0 oscar.XM
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_ServiceRequestHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)) *MockOServiceBOSHandler_ServiceRequestHandler_Call {
+func (_c *MockOServiceBOSHandler_ServiceRequestHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
+func (_m *MockOServiceBOSHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -318,15 +316,15 @@ type MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call struct {
 
 // SetUserInfoFieldsHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
+func (_c *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
 	})
 	return _c
 }
@@ -336,17 +334,17 @@ func (_c *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) Return(_a0 oscar
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call {
+func (_c *MockOServiceBOSHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session) oscar.XMessage {
+func (_m *MockOServiceBOSHandler) UserInfoQueryHandler(ctx context.Context, sess *Session) oscar.XMessage {
 	ret := _m.Called(ctx, sess)
 
 	var r0 oscar.XMessage
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session) oscar.XMessage); ok {
 		r0 = rf(ctx, sess)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
@@ -362,14 +360,14 @@ type MockOServiceBOSHandler_UserInfoQueryHandler_Call struct {
 
 // UserInfoQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceBOSHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *user.Session)) *MockOServiceBOSHandler_UserInfoQueryHandler_Call {
+func (_c *MockOServiceBOSHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *Session)) *MockOServiceBOSHandler_UserInfoQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session))
+		run(args[0].(context.Context), args[1].(*Session))
 	})
 	return _c
 }
@@ -379,7 +377,7 @@ func (_c *MockOServiceBOSHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XMe
 	return _c
 }
 
-func (_c *MockOServiceBOSHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *user.Session) oscar.XMessage) *MockOServiceBOSHandler_UserInfoQueryHandler_Call {
+func (_c *MockOServiceBOSHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *Session) oscar.XMessage) *MockOServiceBOSHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/oservice_chat_mock.go

@@ -9,8 +9,6 @@ import (
 	mock "github.com/stretchr/testify/mock"
 
 	oscar "github.com/mkaminski/goaim/oscar"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockOServiceChatHandler is an autogenerated mock type for the OServiceChatHandler type
@@ -27,11 +25,11 @@ func (_m *MockOServiceChatHandler) EXPECT() *MockOServiceChatHandler_Expecter {
 }
 
 // ClientOnlineHandler provides a mock function with given fields: ctx, snacPayloadIn, sess, chatSessMgr, room
-func (_m *MockOServiceChatHandler) ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *user.Session, chatSessMgr ChatSessionManager, room ChatRoom) error {
+func (_m *MockOServiceChatHandler) ClientOnlineHandler(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *Session, chatSessMgr ChatSessionManager, room ChatRoom) error {
 	ret := _m.Called(ctx, snacPayloadIn, sess, chatSessMgr, room)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *user.Session, ChatSessionManager, ChatRoom) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *Session, ChatSessionManager, ChatRoom) error); ok {
 		r0 = rf(ctx, snacPayloadIn, sess, chatSessMgr, room)
 	} else {
 		r0 = ret.Error(0)
@@ -48,16 +46,16 @@ type MockOServiceChatHandler_ClientOnlineHandler_Call struct {
 // ClientOnlineHandler is a helper method to define mock.On call
 //   - ctx context.Context
 //   - snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline
-//   - sess *user.Session
+//   - sess *Session
 //   - chatSessMgr ChatSessionManager
 //   - room ChatRoom
 func (_e *MockOServiceChatHandler_Expecter) ClientOnlineHandler(ctx interface{}, snacPayloadIn interface{}, sess interface{}, chatSessMgr interface{}, room interface{}) *MockOServiceChatHandler_ClientOnlineHandler_Call {
 	return &MockOServiceChatHandler_ClientOnlineHandler_Call{Call: _e.mock.On("ClientOnlineHandler", ctx, snacPayloadIn, sess, chatSessMgr, room)}
 }
 
-func (_c *MockOServiceChatHandler_ClientOnlineHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *user.Session, chatSessMgr ChatSessionManager, room ChatRoom)) *MockOServiceChatHandler_ClientOnlineHandler_Call {
+func (_c *MockOServiceChatHandler_ClientOnlineHandler_Call) Run(run func(ctx context.Context, snacPayloadIn oscar.SNAC_0x01_0x02_OServiceClientOnline, sess *Session, chatSessMgr ChatSessionManager, room ChatRoom)) *MockOServiceChatHandler_ClientOnlineHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x02_OServiceClientOnline), args[2].(*user.Session), args[3].(ChatSessionManager), args[4].(ChatRoom))
+		run(args[0].(context.Context), args[1].(oscar.SNAC_0x01_0x02_OServiceClientOnline), args[2].(*Session), args[3].(ChatSessionManager), args[4].(ChatRoom))
 	})
 	return _c
 }
@@ -67,7 +65,7 @@ func (_c *MockOServiceChatHandler_ClientOnlineHandler_Call) Return(_a0 error) *M
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_ClientOnlineHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *user.Session, ChatSessionManager, ChatRoom) error) *MockOServiceChatHandler_ClientOnlineHandler_Call {
+func (_c *MockOServiceChatHandler_ClientOnlineHandler_Call) RunAndReturn(run func(context.Context, oscar.SNAC_0x01_0x02_OServiceClientOnline, *Session, ChatSessionManager, ChatRoom) error) *MockOServiceChatHandler_ClientOnlineHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -116,11 +114,11 @@ func (_c *MockOServiceChatHandler_ClientVersionsHandler_Call) RunAndReturn(run f
 }
 
 // IdleNotificationHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceChatHandler) IdleNotificationHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
+func (_m *MockOServiceChatHandler) IdleNotificationHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Error(0)
@@ -136,15 +134,15 @@ type MockOServiceChatHandler_IdleNotificationHandler_Call struct {
 
 // IdleNotificationHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceChatHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceChatHandler_IdleNotificationHandler_Call {
+func (_c *MockOServiceChatHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceChatHandler_IdleNotificationHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
 	})
 	return _c
 }
@@ -154,7 +152,7 @@ func (_c *MockOServiceChatHandler_IdleNotificationHandler_Call) Return(_a0 error
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceChatHandler_IdleNotificationHandler_Call {
+func (_c *MockOServiceChatHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceChatHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -236,21 +234,21 @@ func (_c *MockOServiceChatHandler_RateParamsSubAddHandler_Call) RunAndReturn(run
 }
 
 // ServiceRequestHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceChatHandler) ServiceRequestHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
+func (_m *MockOServiceChatHandler) ServiceRequestHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -266,15 +264,15 @@ type MockOServiceChatHandler_ServiceRequestHandler_Call struct {
 
 // ServiceRequestHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceChatHandler_ServiceRequestHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest)) *MockOServiceChatHandler_ServiceRequestHandler_Call {
+func (_c *MockOServiceChatHandler_ServiceRequestHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x04_OServiceServiceRequest)) *MockOServiceChatHandler_ServiceRequestHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x01_0x04_OServiceServiceRequest))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x01_0x04_OServiceServiceRequest))
 	})
 	return _c
 }
@@ -284,27 +282,27 @@ func (_c *MockOServiceChatHandler_ServiceRequestHandler_Call) Return(_a0 oscar.X
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_ServiceRequestHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x01_0x04_OServiceServiceRequest) (oscar.XMessage, error)) *MockOServiceChatHandler_ServiceRequestHandler_Call {
+func (_c *MockOServiceChatHandler_ServiceRequestHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
+func (_m *MockOServiceChatHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -320,15 +318,15 @@ type MockOServiceChatHandler_SetUserInfoFieldsHandler_Call struct {
 
 // SetUserInfoFieldsHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
+func (_c *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
 	})
 	return _c
 }
@@ -338,17 +336,17 @@ func (_c *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call) Return(_a0 osca
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call {
+func (_c *MockOServiceChatHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session) oscar.XMessage {
+func (_m *MockOServiceChatHandler) UserInfoQueryHandler(ctx context.Context, sess *Session) oscar.XMessage {
 	ret := _m.Called(ctx, sess)
 
 	var r0 oscar.XMessage
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session) oscar.XMessage); ok {
 		r0 = rf(ctx, sess)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
@@ -364,14 +362,14 @@ type MockOServiceChatHandler_UserInfoQueryHandler_Call struct {
 
 // UserInfoQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceChatHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *user.Session)) *MockOServiceChatHandler_UserInfoQueryHandler_Call {
+func (_c *MockOServiceChatHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *Session)) *MockOServiceChatHandler_UserInfoQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session))
+		run(args[0].(context.Context), args[1].(*Session))
 	})
 	return _c
 }
@@ -381,7 +379,7 @@ func (_c *MockOServiceChatHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XM
 	return _c
 }
 
-func (_c *MockOServiceChatHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *user.Session) oscar.XMessage) *MockOServiceChatHandler_UserInfoQueryHandler_Call {
+func (_c *MockOServiceChatHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *Session) oscar.XMessage) *MockOServiceChatHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/oservice_mock.go

@@ -7,8 +7,6 @@ import (
 
 	oscar "github.com/mkaminski/goaim/oscar"
 	mock "github.com/stretchr/testify/mock"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockOServiceHandler is an autogenerated mock type for the OServiceHandler type
@@ -68,11 +66,11 @@ func (_c *MockOServiceHandler_ClientVersionsHandler_Call) RunAndReturn(run func(
 }
 
 // IdleNotificationHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceHandler) IdleNotificationHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
+func (_m *MockOServiceHandler) IdleNotificationHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification) error {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Error(0)
@@ -88,15 +86,15 @@ type MockOServiceHandler_IdleNotificationHandler_Call struct {
 
 // IdleNotificationHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceHandler_IdleNotificationHandler_Call {
+func (_c *MockOServiceHandler_IdleNotificationHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x11_OServiceIdleNotification)) *MockOServiceHandler_IdleNotificationHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x01_0x11_OServiceIdleNotification))
 	})
 	return _c
 }
@@ -106,7 +104,7 @@ func (_c *MockOServiceHandler_IdleNotificationHandler_Call) Return(_a0 error) *M
 	return _c
 }
 
-func (_c *MockOServiceHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceHandler_IdleNotificationHandler_Call {
+func (_c *MockOServiceHandler_IdleNotificationHandler_Call) RunAndReturn(run func(context.Context, *Session, oscar.SNAC_0x01_0x11_OServiceIdleNotification) error) *MockOServiceHandler_IdleNotificationHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }
@@ -188,21 +186,21 @@ func (_c *MockOServiceHandler_RateParamsSubAddHandler_Call) RunAndReturn(run fun
 }
 
 // SetUserInfoFieldsHandler provides a mock function with given fields: ctx, sess, snacPayloadIn
-func (_m *MockOServiceHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
+func (_m *MockOServiceHandler) SetUserInfoFieldsHandler(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error) {
 	ret := _m.Called(ctx, sess, snacPayloadIn)
 
 	var r0 oscar.XMessage
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)); ok {
 		return rf(ctx, sess, snacPayloadIn)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) oscar.XMessage); ok {
 		r0 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) error); ok {
+	if rf, ok := ret.Get(1).(func(context.Context, *Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) error); ok {
 		r1 = rf(ctx, sess, snacPayloadIn)
 	} else {
 		r1 = ret.Error(1)
@@ -218,15 +216,15 @@ type MockOServiceHandler_SetUserInfoFieldsHandler_Call struct {
 
 // SetUserInfoFieldsHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *user.Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceHandler_SetUserInfoFieldsHandler_Call {
+func (_c *MockOServiceHandler_SetUserInfoFieldsHandler_Call) Run(run func(ctx context.Context, sess *Session, snacPayloadIn oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields)) *MockOServiceHandler_SetUserInfoFieldsHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
+		run(args[0].(context.Context), args[1].(*Session), args[2].(oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields))
 	})
 	return _c
 }
@@ -236,17 +234,17 @@ func (_c *MockOServiceHandler_SetUserInfoFieldsHandler_Call) Return(_a0 oscar.XM
 	return _c
 }
 
-func (_c *MockOServiceHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *user.Session, oscar.SNAC_0x01_0x1E_OServiceSetUserInfoFields) (oscar.XMessage, error)) *MockOServiceHandler_SetUserInfoFieldsHandler_Call {
+func (_c *MockOServiceHandler_SetUserInfoFieldsHandler_Call) RunAndReturn(run func(context.Context, *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 *user.Session) oscar.XMessage {
+func (_m *MockOServiceHandler) UserInfoQueryHandler(ctx context.Context, sess *Session) oscar.XMessage {
 	ret := _m.Called(ctx, sess)
 
 	var r0 oscar.XMessage
-	if rf, ok := ret.Get(0).(func(context.Context, *user.Session) oscar.XMessage); ok {
+	if rf, ok := ret.Get(0).(func(context.Context, *Session) oscar.XMessage); ok {
 		r0 = rf(ctx, sess)
 	} else {
 		r0 = ret.Get(0).(oscar.XMessage)
@@ -262,14 +260,14 @@ type MockOServiceHandler_UserInfoQueryHandler_Call struct {
 
 // UserInfoQueryHandler is a helper method to define mock.On call
 //   - ctx context.Context
-//   - sess *user.Session
+//   - sess *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 (_c *MockOServiceHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *user.Session)) *MockOServiceHandler_UserInfoQueryHandler_Call {
+func (_c *MockOServiceHandler_UserInfoQueryHandler_Call) Run(run func(ctx context.Context, sess *Session)) *MockOServiceHandler_UserInfoQueryHandler_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].(*user.Session))
+		run(args[0].(context.Context), args[1].(*Session))
 	})
 	return _c
 }
@@ -279,7 +277,7 @@ func (_c *MockOServiceHandler_UserInfoQueryHandler_Call) Return(_a0 oscar.XMessa
 	return _c
 }
 
-func (_c *MockOServiceHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *user.Session) oscar.XMessage) *MockOServiceHandler_UserInfoQueryHandler_Call {
+func (_c *MockOServiceHandler_UserInfoQueryHandler_Call) RunAndReturn(run func(context.Context, *Session) oscar.XMessage) *MockOServiceHandler_UserInfoQueryHandler_Call {
 	_c.Call.Return(run)
 	return _c
 }

server/oservice_test.go

@@ -2,7 +2,6 @@ package server
 
 import (
 	"bytes"
-	"github.com/mkaminski/goaim/user"
 	"github.com/stretchr/testify/mock"
 	"testing"
 	"time"
@@ -21,7 +20,7 @@ func TestReceiveAndSendServiceRequest(t *testing.T) {
 		chatRoom *ChatRoom
 		// userSession is the session of the user requesting the chat service
 		// info
-		userSession *user.Session
+		userSession *Session
 		// inputSNAC is the SNAC sent by the sender client
 		inputSNAC oscar.SNAC_0x01_0x04_OServiceServiceRequest
 		// expectSNACFrame is the SNAC frame sent from the server to the recipient
@@ -120,7 +119,7 @@ func TestReceiveAndSendServiceRequest(t *testing.T) {
 			if tc.chatRoom != nil {
 				sm.EXPECT().
 					NewSessionWithSN(tc.userSession.ID(), tc.userSession.ScreenName()).
-					Return(&user.Session{}).
+					Return(&Session{}).
 					Maybe()
 				cr.Register(*tc.chatRoom, sm)
 			}

server/router.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/mkaminski/goaim/user"
 	"io"
 	"log/slog"
 	"net"
@@ -28,7 +27,7 @@ func NewBOSServiceRouter(logger *slog.Logger, cfg Config, fm FeedbagManager, sm
 		RouteLogger: RouteLogger{
 			Logger: logger,
 		},
-		NewChatSessMgr: func() ChatSessionManager { return user.NewSessionManager(logger) },
+		NewChatSessMgr: func() ChatSessionManager { return NewSessionManager(logger) },
 	}
 }
 
@@ -58,7 +57,7 @@ type BOSServiceRouter struct {
 	NewChatSessMgr func() ChatSessionManager
 }
 
-func (rt *BOSServiceRouter) Route(ctx context.Context, sess *user.Session, r io.Reader, w io.Writer, sequence *uint32) error {
+func (rt *BOSServiceRouter) Route(ctx context.Context, sess *Session, r io.Reader, w io.Writer, sequence *uint32) error {
 	snac := oscar.SnacFrame{}
 	if err := oscar.Unmarshal(&snac, r); err != nil {
 		return err
@@ -103,14 +102,14 @@ func (rt *BOSServiceRouter) Route(ctx context.Context, sess *user.Session, r io.
 	return err
 }
 
-func (rt *BOSServiceRouter) Signout(ctx context.Context, logger *slog.Logger, sess *user.Session) {
+func (rt *BOSServiceRouter) Signout(ctx context.Context, logger *slog.Logger, sess *Session) {
 	if err := BroadcastDeparture(ctx, sess, rt.sm, rt.fm); err != nil {
 		logger.ErrorContext(ctx, "error notifying departure", "err", err.Error())
 	}
 	rt.sm.Remove(sess)
 }
 
-func (rt *BOSServiceRouter) VerifyLogin(conn net.Conn) (*user.Session, uint32, error) {
+func (rt *BOSServiceRouter) VerifyLogin(conn net.Conn) (*Session, uint32, error) {
 	seq := uint32(100)
 
 	flap, err := SendAndReceiveSignonFrame(conn, &seq)
@@ -187,7 +186,7 @@ type ChatServiceRouter struct {
 	RouteLogger
 }
 
-func (rt *ChatServiceRouter) Route(ctx context.Context, sess *user.Session, r io.Reader, w io.Writer, sequence *uint32, chatSessMgr ChatSessionManager, room ChatRoom) error {
+func (rt *ChatServiceRouter) Route(ctx context.Context, sess *Session, r io.Reader, w io.Writer, sequence *uint32, chatSessMgr ChatSessionManager, room ChatRoom) error {
 	snac := oscar.SnacFrame{}
 	if err := oscar.Unmarshal(&snac, r); err != nil {
 		return err

server/session.go

@@ -1,76 +1,218 @@
 package server
 
 import (
-	"errors"
+	"github.com/google/uuid"
+	"github.com/mkaminski/goaim/oscar"
 	"sync"
 	"time"
+)
 
-	"github.com/mkaminski/goaim/oscar"
+var CapChat, _ = uuid.MustParse("748F2420-6287-11D1-8222-444553540000").MarshalBinary()
+
+type SessSendStatus int
+
+const (
+	// SessSendOK indicates message was sent to recipient
+	SessSendOK SessSendStatus = iota
+	// SessSendClosed indicates send did not complete because session is closed
+	SessSendClosed
+	// SessQueueFull indicates send failed due to full queue -- client is likely
+	// dead
+	SessQueueFull
 )
 
-var ErrSignedOff = errors.New("user signed off")
-
-type ChatRoom struct {
-	CreateTime     time.Time
-	DetailLevel    uint8
-	Exchange       uint16
-	Cookie         string
-	InstanceNumber uint16
-	Name           string
-}
-
-func (c ChatRoom) TLVList() []oscar.TLV {
-	return []oscar.TLV{
-		oscar.NewTLV(0x00c9, uint16(15)),
-		oscar.NewTLV(0x00ca, uint32(c.CreateTime.Unix())),
-		oscar.NewTLV(0x00d1, uint16(1024)),
-		oscar.NewTLV(0x00d2, uint16(100)),
-		oscar.NewTLV(0x00d5, uint8(2)),
-		oscar.NewTLV(0x006a, c.Name),
-		oscar.NewTLV(0x00d3, c.Name),
-	}
+type Session struct {
+	awayMessage string
+	closed      bool
+	id          string
+	idle        bool
+	idleTime    time.Time
+	invisible   bool
+	msgCh       chan oscar.XMessage
+	mutex       sync.RWMutex
+	screenName  string
+	signonTime  time.Time
+	stopCh      chan struct{}
+	warning     uint16
 }
 
-type ChatRegistry struct {
-	chatRoomStore map[string]ChatRoom
-	smStore       map[string]ChatSessionManager
-	mapMutex      sync.RWMutex
+func (s *Session) IncreaseWarning(incr uint16) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.warning += incr
 }
 
-func NewChatRegistry() *ChatRegistry {
-	return &ChatRegistry{
-		chatRoomStore: make(map[string]ChatRoom),
-		smStore:       make(map[string]ChatSessionManager),
+func (s *Session) SetInvisible(invisible bool) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.invisible = invisible
+}
+
+func (s *Session) SetScreenName(screenName string) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.screenName = screenName
+}
+
+func (s *Session) ScreenName() string {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	return s.screenName
+}
+
+func (s *Session) SetID(ID string) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.id = ID
+}
+
+func (s *Session) SetSignonTime(t time.Time) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.signonTime = t
+}
+
+func (s *Session) ID() string {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	return s.id
+}
+
+func (s *Session) Invisible() bool {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	return s.invisible
+}
+
+func (s *Session) SetIdle(dur time.Duration) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.idle = true
+	// set the time the user became idle
+	s.idleTime = time.Now().Add(-dur)
+}
+
+func (s *Session) SetActive() {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.idle = false
+}
+
+func (s *Session) Idle() bool {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	return s.idle
+}
+
+func (s *Session) SetAwayMessage(awayMessage string) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	s.awayMessage = awayMessage
+}
+
+func (s *Session) AwayMessage() string {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	return s.awayMessage
+}
+
+func (s *Session) TLVUserInfo() oscar.TLVUserInfo {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+	return oscar.TLVUserInfo{
+		ScreenName:   s.screenName,
+		WarningLevel: s.warning,
+		TLVBlock: oscar.TLVBlock{
+			TLVList: s.UserInfo(),
+		},
+	}
+}
+
+func (s *Session) UserInfo() oscar.TLVList {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+
+	// sign-in timestamp
+	tlvs := oscar.TLVList{}
+
+	tlvs.AddTLV(oscar.NewTLV(0x03, uint32(s.signonTime.Unix())))
+
+	// away message status
+	if s.awayMessage != "" {
+		tlvs.AddTLV(oscar.NewTLV(0x01, uint16(0x0010)|uint16(0x0020)))
+	} else {
+		tlvs.AddTLV(oscar.NewTLV(0x01, uint16(0x0010)))
+	}
+
+	// invisibility status
+	if s.invisible {
+		tlvs.AddTLV(oscar.NewTLV(0x06, uint16(0x0100)))
+	} else {
+		tlvs.AddTLV(oscar.NewTLV(0x06, uint16(0x0000)))
+	}
+
+	// idle status
+	if s.idle {
+		tlvs.AddTLV(oscar.NewTLV(0x04, uint16(time.Now().Sub(s.idleTime).Seconds())))
+	} else {
+		tlvs.AddTLV(oscar.NewTLV(0x04, uint16(0)))
 	}
+
+	// capabilities
+	var caps []byte
+	// chat capability
+	caps = append(caps, CapChat...)
+	tlvs.AddTLV(oscar.NewTLV(0x0D, caps))
+
+	return tlvs
+}
+
+func (s *Session) Warning() uint16 {
+	var w uint16
+	s.mutex.RLock()
+	w = s.warning
+	s.mutex.RUnlock()
+	return w
 }
 
-func (c *ChatRegistry) Register(room ChatRoom, sm ChatSessionManager) {
-	c.mapMutex.Lock()
-	defer c.mapMutex.Unlock()
-	c.chatRoomStore[room.Cookie] = room
-	c.smStore[room.Cookie] = sm
+func (s *Session) RecvMessage() chan oscar.XMessage {
+	return s.msgCh
 }
 
-func (c *ChatRegistry) Retrieve(chatID string) (ChatRoom, ChatSessionManager, error) {
-	c.mapMutex.RLock()
-	defer c.mapMutex.RUnlock()
-	cr, found := c.chatRoomStore[chatID]
-	if !found {
-		return ChatRoom{}, nil, errors.New("unable to find chat room")
+func (s *Session) SendMessage(msg oscar.XMessage) SessSendStatus {
+	s.mutex.Lock()
+	if s.closed {
+		return SessSendClosed
+	}
+	s.mutex.Unlock()
+	select {
+	case s.msgCh <- msg:
+		return SessSendOK
+	case <-s.stopCh:
+		return SessSendClosed
+	default:
+		return SessQueueFull
 	}
-	sm, found := c.smStore[chatID]
-	if !found {
-		panic("unable to find session manager for chat")
+}
+
+func (s *Session) Close() {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+	if s.closed {
+		return
 	}
-	return cr, sm, nil
+	close(s.stopCh)
+	s.closed = true
+}
+
+func (s *Session) Closed() <-chan struct{} {
+	return s.stopCh
 }
 
-func (c *ChatRegistry) MaybeRemoveRoom(chatID string) {
-	c.mapMutex.Lock()
-	defer c.mapMutex.Unlock()
-	sm, found := c.smStore[chatID]
-	if found && sm.Empty() {
-		delete(c.chatRoomStore, chatID)
-		delete(c.smStore, chatID)
+func NewSession() *Session {
+	return &Session{
+		msgCh:      make(chan oscar.XMessage, 1000),
+		stopCh:     make(chan struct{}),
+		signonTime: time.Now(),
 	}
 }

user/session_manager.go → server/session_manager.go

@@ -1,4 +1,4 @@
-package user
+package server
 
 import (
 	"context"

server/session_manager_mock.go

@@ -7,8 +7,6 @@ import (
 
 	oscar "github.com/mkaminski/goaim/oscar"
 	mock "github.com/stretchr/testify/mock"
-
-	user "github.com/mkaminski/goaim/user"
 )
 
 // MockSessionManager is an autogenerated mock type for the SessionManager type
@@ -135,15 +133,15 @@ func (_c *MockSessionManager_Empty_Call) RunAndReturn(run func() bool) *MockSess
 }
 
 // NewSessionWithSN provides a mock function with given fields: sessID, screenName
-func (_m *MockSessionManager) NewSessionWithSN(sessID string, screenName string) *user.Session {
+func (_m *MockSessionManager) NewSessionWithSN(sessID string, screenName string) *Session {
 	ret := _m.Called(sessID, screenName)
 
-	var r0 *user.Session
-	if rf, ok := ret.Get(0).(func(string, string) *user.Session); ok {
+	var r0 *Session
+	if rf, ok := ret.Get(0).(func(string, string) *Session); ok {
 		r0 = rf(sessID, screenName)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*user.Session)
+			r0 = ret.Get(0).(*Session)
 		}
 	}
 
@@ -169,18 +167,18 @@ func (_c *MockSessionManager_NewSessionWithSN_Call) Run(run func(sessID string,
 	return _c
 }
 
-func (_c *MockSessionManager_NewSessionWithSN_Call) Return(_a0 *user.Session) *MockSessionManager_NewSessionWithSN_Call {
+func (_c *MockSessionManager_NewSessionWithSN_Call) Return(_a0 *Session) *MockSessionManager_NewSessionWithSN_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockSessionManager_NewSessionWithSN_Call) RunAndReturn(run func(string, string) *user.Session) *MockSessionManager_NewSessionWithSN_Call {
+func (_c *MockSessionManager_NewSessionWithSN_Call) RunAndReturn(run func(string, string) *Session) *MockSessionManager_NewSessionWithSN_Call {
 	_c.Call.Return(run)
 	return _c
 }
 
 // Remove provides a mock function with given fields: sess
-func (_m *MockSessionManager) Remove(sess *user.Session) {
+func (_m *MockSessionManager) Remove(sess *Session) {
 	_m.Called(sess)
 }
 
@@ -190,14 +188,14 @@ type MockSessionManager_Remove_Call struct {
 }
 
 // Remove is a helper method to define mock.On call
-//   - sess *user.Session
+//   - sess *Session
 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 *user.Session)) *MockSessionManager_Remove_Call {
+func (_c *MockSessionManager_Remove_Call) Run(run func(sess *Session)) *MockSessionManager_Remove_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(*user.Session))
+		run(args[0].(*Session))
 	})
 	return _c
 }
@@ -207,25 +205,25 @@ func (_c *MockSessionManager_Remove_Call) Return() *MockSessionManager_Remove_Ca
 	return _c
 }
 
-func (_c *MockSessionManager_Remove_Call) RunAndReturn(run func(*user.Session)) *MockSessionManager_Remove_Call {
+func (_c *MockSessionManager_Remove_Call) RunAndReturn(run func(*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) (*user.Session, bool) {
+func (_m *MockSessionManager) Retrieve(ID string) (*Session, bool) {
 	ret := _m.Called(ID)
 
-	var r0 *user.Session
+	var r0 *Session
 	var r1 bool
-	if rf, ok := ret.Get(0).(func(string) (*user.Session, bool)); ok {
+	if rf, ok := ret.Get(0).(func(string) (*Session, bool)); ok {
 		return rf(ID)
 	}
-	if rf, ok := ret.Get(0).(func(string) *user.Session); ok {
+	if rf, ok := ret.Get(0).(func(string) *Session); ok {
 		r0 = rf(ID)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*user.Session)
+			r0 = ret.Get(0).(*Session)
 		}
 	}
 
@@ -256,26 +254,26 @@ func (_c *MockSessionManager_Retrieve_Call) Run(run func(ID string)) *MockSessio
 	return _c
 }
 
-func (_c *MockSessionManager_Retrieve_Call) Return(_a0 *user.Session, _a1 bool) *MockSessionManager_Retrieve_Call {
+func (_c *MockSessionManager_Retrieve_Call) Return(_a0 *Session, _a1 bool) *MockSessionManager_Retrieve_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *MockSessionManager_Retrieve_Call) RunAndReturn(run func(string) (*user.Session, bool)) *MockSessionManager_Retrieve_Call {
+func (_c *MockSessionManager_Retrieve_Call) RunAndReturn(run func(string) (*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) *user.Session {
+func (_m *MockSessionManager) RetrieveByScreenName(screenName string) *Session {
 	ret := _m.Called(screenName)
 
-	var r0 *user.Session
-	if rf, ok := ret.Get(0).(func(string) *user.Session); ok {
+	var r0 *Session
+	if rf, ok := ret.Get(0).(func(string) *Session); ok {
 		r0 = rf(screenName)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*user.Session)
+			r0 = ret.Get(0).(*Session)
 		}
 	}
 
@@ -300,12 +298,12 @@ func (_c *MockSessionManager_RetrieveByScreenName_Call) Run(run func(screenName
 	return _c
 }
 
-func (_c *MockSessionManager_RetrieveByScreenName_Call) Return(_a0 *user.Session) *MockSessionManager_RetrieveByScreenName_Call {
+func (_c *MockSessionManager_RetrieveByScreenName_Call) Return(_a0 *Session) *MockSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *MockSessionManager_RetrieveByScreenName_Call) RunAndReturn(run func(string) *user.Session) *MockSessionManager_RetrieveByScreenName_Call {
+func (_c *MockSessionManager_RetrieveByScreenName_Call) RunAndReturn(run func(string) *Session) *MockSessionManager_RetrieveByScreenName_Call {
 	_c.Call.Return(run)
 	return _c
 }

user/session_test.go → server/session_test.go

@@ -1,4 +1,4 @@
-package user
+package server
 
 import (
 	"github.com/mkaminski/goaim/oscar"

server/test_helpers.go

@@ -1,45 +1,44 @@
 package server
 
 import (
-	"github.com/mkaminski/goaim/user"
 	"time"
 )
 
 // sessOptWarning sets a warning level on the session object
-func sessOptWarning(level uint16) func(session *user.Session) {
-	return func(session *user.Session) {
+func sessOptWarning(level uint16) func(session *Session) {
+	return func(session *Session) {
 		session.IncreaseWarning(level)
 	}
 }
 
 // sessOptCannedID sets a canned session ID ("user-sess-id") on the session
 // object
-func sessOptCannedID(session *user.Session) {
+func sessOptCannedID(session *Session) {
 	session.SetID("user-sess-id")
 }
 
 // sessOptCannedAwayMessage sets a canned away message ("this is my away
 // message!") on the session object
-func sessOptCannedAwayMessage(session *user.Session) {
+func sessOptCannedAwayMessage(session *Session) {
 	session.SetAwayMessage("this is my away message!")
 }
 
 // sessOptCannedSignonTime sets a canned sign-on time (1696790127565) on the
 // session object
-func sessOptCannedSignonTime(session *user.Session) {
+func sessOptCannedSignonTime(session *Session) {
 	session.SetSignonTime(time.UnixMilli(1696790127565))
 }
 
 // sessOptCannedSignonTime sets the invisible flag to true on the session
 // object
-func sessOptInvisible(session *user.Session) {
+func sessOptInvisible(session *Session) {
 	session.SetInvisible(true)
 }
 
 // newTestSession creates a session object with 0 or more functional options
 // applied
-func newTestSession(screenName string, options ...func(session *user.Session)) *user.Session {
-	s := user.NewSession()
+func newTestSession(screenName string, options ...func(session *Session)) *Session {
+	s := NewSession()
 	s.SetScreenName(screenName)
 	for _, op := range options {
 		op(s)

server/types.go

@@ -3,12 +3,11 @@ package server
 import (
 	"context"
 	"github.com/mkaminski/goaim/oscar"
-	"github.com/mkaminski/goaim/user"
 	"time"
 )
 
 type FeedbagManager interface {
-	Blocked(sn1, sn2 string) (user.BlockedState, error)
+	Blocked(sn1, sn2 string) (BlockedState, error)
 	Buddies(screenName string) ([]string, error)
 	Delete(screenName string, items []oscar.FeedbagItem) error
 	InterestedUsers(screenName string) ([]string, error)
@@ -21,17 +20,17 @@ type SessionManager interface {
 	Broadcast(ctx context.Context, msg oscar.XMessage)
 	BroadcastToScreenNames(ctx context.Context, screenNames []string, msg oscar.XMessage)
 	Empty() bool
-	NewSessionWithSN(sessID string, screenName string) *user.Session
-	Remove(sess *user.Session)
-	Retrieve(ID string) (*user.Session, bool)
-	RetrieveByScreenName(screenName string) *user.Session
+	NewSessionWithSN(sessID string, screenName string) *Session
+	Remove(sess *Session)
+	Retrieve(ID string) (*Session, bool)
+	RetrieveByScreenName(screenName string) *Session
 	SendToScreenName(ctx context.Context, screenName string, msg oscar.XMessage)
 }
 
 type ChatSessionManager interface {
 	SessionManager
-	BroadcastExcept(ctx context.Context, except *user.Session, msg oscar.XMessage)
-	Participants() []*user.Session
+	BroadcastExcept(ctx context.Context, except *Session, msg oscar.XMessage)
+	Participants() []*Session
 }
 
 type ProfileManager interface {

user/session.go

@@ -1,218 +0,0 @@
-package user
-
-import (
-	"github.com/google/uuid"
-	"github.com/mkaminski/goaim/oscar"
-	"sync"
-	"time"
-)
-
-var CapChat, _ = uuid.MustParse("748F2420-6287-11D1-8222-444553540000").MarshalBinary()
-
-type SessSendStatus int
-
-const (
-	// SessSendOK indicates message was sent to recipient
-	SessSendOK SessSendStatus = iota
-	// SessSendClosed indicates send did not complete because session is closed
-	SessSendClosed
-	// SessQueueFull indicates send failed due to full queue -- client is likely
-	// dead
-	SessQueueFull
-)
-
-type Session struct {
-	awayMessage string
-	closed      bool
-	id          string
-	idle        bool
-	idleTime    time.Time
-	invisible   bool
-	msgCh       chan oscar.XMessage
-	mutex       sync.RWMutex
-	screenName  string
-	signonTime  time.Time
-	stopCh      chan struct{}
-	warning     uint16
-}
-
-func (s *Session) IncreaseWarning(incr uint16) {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	s.warning += incr
-}
-
-func (s *Session) SetInvisible(invisible bool) {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	s.invisible = invisible
-}
-
-func (s *Session) SetScreenName(screenName string) {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	s.screenName = screenName
-}
-
-func (s *Session) ScreenName() string {
-	s.mutex.RLock()
-	defer s.mutex.RUnlock()
-	return s.screenName
-}
-
-func (s *Session) SetID(ID string) {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	s.id = ID
-}
-
-func (s *Session) SetSignonTime(t time.Time) {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	s.signonTime = t
-}
-
-func (s *Session) ID() string {
-	s.mutex.RLock()
-	defer s.mutex.RUnlock()
-	return s.id
-}
-
-func (s *Session) Invisible() bool {
-	s.mutex.RLock()
-	defer s.mutex.RUnlock()
-	return s.invisible
-}
-
-func (s *Session) SetIdle(dur time.Duration) {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	s.idle = true
-	// set the time the user became idle
-	s.idleTime = time.Now().Add(-dur)
-}
-
-func (s *Session) SetActive() {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	s.idle = false
-}
-
-func (s *Session) Idle() bool {
-	s.mutex.RLock()
-	defer s.mutex.RUnlock()
-	return s.idle
-}
-
-func (s *Session) SetAwayMessage(awayMessage string) {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	s.awayMessage = awayMessage
-}
-
-func (s *Session) AwayMessage() string {
-	s.mutex.RLock()
-	defer s.mutex.RUnlock()
-	return s.awayMessage
-}
-
-func (s *Session) TLVUserInfo() oscar.TLVUserInfo {
-	s.mutex.RLock()
-	defer s.mutex.RUnlock()
-	return oscar.TLVUserInfo{
-		ScreenName:   s.screenName,
-		WarningLevel: s.warning,
-		TLVBlock: oscar.TLVBlock{
-			TLVList: s.UserInfo(),
-		},
-	}
-}
-
-func (s *Session) UserInfo() oscar.TLVList {
-	s.mutex.RLock()
-	defer s.mutex.RUnlock()
-
-	// sign-in timestamp
-	tlvs := oscar.TLVList{}
-
-	tlvs.AddTLV(oscar.NewTLV(0x03, uint32(s.signonTime.Unix())))
-
-	// away message status
-	if s.awayMessage != "" {
-		tlvs.AddTLV(oscar.NewTLV(0x01, uint16(0x0010)|uint16(0x0020)))
-	} else {
-		tlvs.AddTLV(oscar.NewTLV(0x01, uint16(0x0010)))
-	}
-
-	// invisibility status
-	if s.invisible {
-		tlvs.AddTLV(oscar.NewTLV(0x06, uint16(0x0100)))
-	} else {
-		tlvs.AddTLV(oscar.NewTLV(0x06, uint16(0x0000)))
-	}
-
-	// idle status
-	if s.idle {
-		tlvs.AddTLV(oscar.NewTLV(0x04, uint16(time.Now().Sub(s.idleTime).Seconds())))
-	} else {
-		tlvs.AddTLV(oscar.NewTLV(0x04, uint16(0)))
-	}
-
-	// capabilities
-	var caps []byte
-	// chat capability
-	caps = append(caps, CapChat...)
-	tlvs.AddTLV(oscar.NewTLV(0x0D, caps))
-
-	return tlvs
-}
-
-func (s *Session) Warning() uint16 {
-	var w uint16
-	s.mutex.RLock()
-	w = s.warning
-	s.mutex.RUnlock()
-	return w
-}
-
-func (s *Session) RecvMessage() chan oscar.XMessage {
-	return s.msgCh
-}
-
-func (s *Session) SendMessage(msg oscar.XMessage) SessSendStatus {
-	s.mutex.Lock()
-	if s.closed {
-		return SessSendClosed
-	}
-	s.mutex.Unlock()
-	select {
-	case s.msgCh <- msg:
-		return SessSendOK
-	case <-s.stopCh:
-		return SessSendClosed
-	default:
-		return SessQueueFull
-	}
-}
-
-func (s *Session) Close() {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	if s.closed {
-		return
-	}
-	close(s.stopCh)
-	s.closed = true
-}
-
-func (s *Session) Closed() <-chan struct{} {
-	return s.stopCh
-}
-
-func NewSession() *Session {
-	return &Session{
-		msgCh:      make(chan oscar.XMessage, 1000),
-		stopCh:     make(chan struct{}),
-		signonTime: time.Now(),
-	}
-}