increase test coverage in random areas

handler/buddy.go

@@ -24,10 +24,10 @@ func (s BuddyService) RightsQueryHandler(_ context.Context, frameIn oscar.SNACFr
 		Body: oscar.SNAC_0x03_0x03_BuddyRightsReply{
 			TLVRestBlock: oscar.TLVRestBlock{
 				TLVList: oscar.TLVList{
-					oscar.NewTLV(0x01, uint16(100)),
-					oscar.NewTLV(0x02, uint16(100)),
-					oscar.NewTLV(0x03, uint16(100)),
-					oscar.NewTLV(0x04, uint16(100)),
+					oscar.NewTLV(oscar.BuddyTLVTagsParmMaxBuddies, uint16(100)),
+					oscar.NewTLV(oscar.BuddyTLVTagsParmMaxWatchers, uint16(100)),
+					oscar.NewTLV(oscar.BuddyTLVTagsParmMaxIcqBroad, uint16(100)),
+					oscar.NewTLV(oscar.BuddyTLVTagsParmMaxTempBuddies, uint16(100)),
 				},
 			},
 		},

handler/buddy_test.go

@@ -0,0 +1,33 @@
+package handler
+
+import (
+	"testing"
+
+	"github.com/mkaminski/goaim/oscar"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuddyService_RightsQueryHandler(t *testing.T) {
+	svc := NewBuddyService()
+
+	want := oscar.SNACMessage{
+		Frame: oscar.SNACFrame{
+			FoodGroup: oscar.Buddy,
+			SubGroup:  oscar.BuddyRightsReply,
+			RequestID: 1234,
+		},
+		Body: oscar.SNAC_0x03_0x03_BuddyRightsReply{
+			TLVRestBlock: oscar.TLVRestBlock{
+				TLVList: oscar.TLVList{
+					oscar.NewTLV(oscar.BuddyTLVTagsParmMaxBuddies, uint16(100)),
+					oscar.NewTLV(oscar.BuddyTLVTagsParmMaxWatchers, uint16(100)),
+					oscar.NewTLV(oscar.BuddyTLVTagsParmMaxIcqBroad, uint16(100)),
+					oscar.NewTLV(oscar.BuddyTLVTagsParmMaxTempBuddies, uint16(100)),
+				},
+			},
+		},
+	}
+	have := svc.RightsQueryHandler(nil, oscar.SNACFrame{RequestID: 1234})
+
+	assert.Equal(t, want, have)
+}

handler/chat_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/stretchr/testify/mock"
 )
 
-func TestSendAndReceiveChatChannelMsgToHost(t *testing.T) {
+func TestChatService_ChannelMsgToHostHandler(t *testing.T) {
 	cases := []struct {
 		// name is the unit test name
 		name string
@@ -133,9 +133,7 @@ func TestSendAndReceiveChatChannelMsgToHost(t *testing.T) {
 			chatSessMgr.EXPECT().
 				RelayToAllExcept(mock.Anything, tc.userSession, tc.expectSNACToParticipants)
 
-			svc := ChatService{
-				chatRegistry: state.NewChatRegistry(),
-			}
+			svc := NewChatService(state.NewChatRegistry())
 			svc.chatRegistry.Register(state.ChatRoom{Cookie: chatID}, chatSessMgr)
 
 			outputSNAC, err := svc.ChannelMsgToHostHandler(context.Background(), tc.userSession, chatID,

handler/icbm_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/stretchr/testify/mock"
 )
 
-func TestSendAndReceiveChannelMsgToHost(t *testing.T) {
+func TestICBMService_ChannelMsgToHostHandler(t *testing.T) {
 	cases := []struct {
 		// name is the unit test name
 		name string
@@ -245,10 +245,7 @@ func TestSendAndReceiveChannelMsgToHost(t *testing.T) {
 			//
 			// send input SNAC
 			//
-			svc := ICBMService{
-				messageRelayer: messageRelayer,
-				feedbagManager: feedbagManager,
-			}
+			svc := NewICBMService(messageRelayer, feedbagManager)
 			outputSNAC, err := svc.ChannelMsgToHostHandler(nil, tc.senderSession, tc.inputSNAC.Frame,
 				tc.inputSNAC.Body.(oscar.SNAC_0x04_0x06_ICBMChannelMsgToHost))
 			assert.NoError(t, err)
@@ -260,7 +257,7 @@ func TestSendAndReceiveChannelMsgToHost(t *testing.T) {
 	}
 }
 
-func TestSendAndReceiveClientEvent(t *testing.T) {
+func TestICBMService_ClientEventHandler(t *testing.T) {
 	cases := []struct {
 		// name is the unit test name
 		name string
@@ -338,17 +335,14 @@ func TestSendAndReceiveClientEvent(t *testing.T) {
 			// send input SNAC
 			//
 			senderSession := newTestSession(tc.senderScreenName)
-			svc := ICBMService{
-				messageRelayer: messageRelayer,
-				feedbagManager: feedbagManager,
-			}
+			svc := NewICBMService(messageRelayer, feedbagManager)
 			assert.NoError(t, svc.ClientEventHandler(nil, senderSession, tc.inputSNAC.Frame,
 				tc.inputSNAC.Body.(oscar.SNAC_0x04_0x14_ICBMClientEvent)))
 		})
 	}
 }
 
-func TestSendAndReceiveEvilRequest(t *testing.T) {
+func TestICBMService_EvilRequestHandler(t *testing.T) {
 	cases := []struct {
 		// name is the unit test name
 		name string
@@ -575,10 +569,7 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 			// send input SNAC
 			//
 			senderSession := newTestSession(tc.senderSession.ScreenName())
-			svc := ICBMService{
-				messageRelayer: messageRelayer,
-				feedbagManager: feedbagManager,
-			}
+			svc := NewICBMService(messageRelayer, feedbagManager)
 			outputSNAC, err := svc.EvilRequestHandler(nil, senderSession, tc.inputSNAC.Frame,
 				tc.inputSNAC.Body.(oscar.SNAC_0x04_0x08_ICBMEvilRequest))
 			assert.NoError(t, err)
@@ -586,3 +577,26 @@ func TestSendAndReceiveEvilRequest(t *testing.T) {
 		})
 	}
 }
+
+func TestICBMService_ParameterQueryHandler(t *testing.T) {
+	svc := NewICBMService(nil, nil)
+
+	have := svc.ParameterQueryHandler(nil, oscar.SNACFrame{RequestID: 1234})
+	want := oscar.SNACMessage{
+		Frame: oscar.SNACFrame{
+			FoodGroup: oscar.ICBM,
+			SubGroup:  oscar.ICBMParameterReply,
+			RequestID: 1234,
+		},
+		Body: oscar.SNAC_0x04_0x05_ICBMParameterReply{
+			MaxSlots:             100,
+			ICBMFlags:            3,
+			MaxIncomingICBMLen:   512,
+			MaxSourceEvil:        999,
+			MaxDestinationEvil:   999,
+			MinInterICBMInterval: 0,
+		},
+	}
+
+	assert.Equal(t, want, have)
+}

oscar/snacs.go

@@ -357,6 +357,11 @@ const (
 	BuddyDeparted            uint16 = 0x000C
 	BuddyAddTempBuddies      uint16 = 0x000F
 	BuddyDelTempBuddies      uint16 = 0x0010
+
+	BuddyTLVTagsParmMaxBuddies     uint16 = 0x01
+	BuddyTLVTagsParmMaxWatchers    uint16 = 0x02
+	BuddyTLVTagsParmMaxIcqBroad    uint16 = 0x03
+	BuddyTLVTagsParmMaxTempBuddies uint16 = 0x04
 )
 
 type SNAC_0x03_0x02_BuddyRightsQuery struct {

server/alert_test.go

@@ -60,11 +60,7 @@ func TestAlertRouter_RouteAlert(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			router := AlertRouter{
-				RouteLogger: RouteLogger{
-					Logger: NewLogger(Config{}),
-				},
-			}
+			router := NewAlertRouter(NewLogger(Config{}))
 
 			bufIn := &bytes.Buffer{}
 			assert.NoError(t, oscar.Marshal(tc.input.Body, bufIn))

server/buddy_test.go

@@ -0,0 +1,131 @@
+package server
+
+import (
+	"bytes"
+	"log/slog"
+	"testing"
+
+	"github.com/mkaminski/goaim/oscar"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func TestBuddyRouter_RouteBuddy(t *testing.T) {
+	cases := []struct {
+		// name is the unit test name
+		name string
+		// input is the request payload
+		input oscar.SNACMessage
+		// output is the response payload
+		output oscar.SNACMessage
+		// handlerErr is the mocked handler error response
+		handlerErr error
+		// expectErr is the expected error returned by the router
+		expectErr error
+	}{
+		{
+			name: "receive BuddyRightsQuery, return BuddyRightsReply",
+			input: oscar.SNACMessage{
+				Frame: oscar.SNACFrame{
+					FoodGroup: oscar.Buddy,
+					SubGroup:  oscar.BuddyRightsQuery,
+				},
+				Body: oscar.SNAC_0x03_0x02_BuddyRightsQuery{
+					TLVRestBlock: oscar.TLVRestBlock{
+						TLVList: oscar.TLVList{
+							oscar.NewTLV(0x01, uint16(1000)),
+						},
+					},
+				},
+			},
+			output: oscar.SNACMessage{
+				Frame: oscar.SNACFrame{
+					FoodGroup: oscar.Buddy,
+					SubGroup:  oscar.BuddyRightsReply,
+				},
+				Body: oscar.SNAC_0x03_0x03_BuddyRightsReply{
+					TLVRestBlock: oscar.TLVRestBlock{
+						TLVList: oscar.TLVList{
+							oscar.NewTLV(0x01, uint16(1000)),
+						},
+					},
+				},
+			},
+		},
+		{
+			name: "receive ChatRowListInfo, return ErrUnsupportedSubGroup",
+			input: oscar.SNACMessage{
+				Frame: oscar.SNACFrame{
+					FoodGroup: oscar.Chat,
+					SubGroup:  oscar.ChatRowListInfo,
+				},
+				Body: struct{}{},
+			},
+			expectErr: ErrUnsupportedSubGroup,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			svc := newMockBuddyHandler(t)
+			svc.EXPECT().
+				RightsQueryHandler(mock.Anything, tc.input.Frame).
+				Return(tc.output).
+				Maybe()
+
+			router := NewBuddyRouter(NewLogger(Config{}), svc)
+
+			bufIn := &bytes.Buffer{}
+			assert.NoError(t, oscar.Marshal(tc.input.Body, bufIn))
+
+			bufOut := &bytes.Buffer{}
+			seq := uint32(0)
+
+			err := router.RouteBuddy(nil, tc.input.Frame, bufIn, bufOut, &seq)
+			assert.ErrorIs(t, err, tc.expectErr)
+			if tc.expectErr != nil {
+				return
+			}
+
+			// verify the FLAP frame
+			flap := oscar.FLAPFrame{}
+			assert.NoError(t, oscar.Unmarshal(&flap, bufOut))
+
+			// make sure the sequence increments
+			assert.Equal(t, seq, uint32(1))
+			assert.Equal(t, flap.Sequence, uint16(0))
+
+			flapBuf, err := flap.SNACBuffer(bufOut)
+			assert.NoError(t, err)
+
+			// verify the SNAC frame
+			snacFrame := oscar.SNACFrame{}
+			assert.NoError(t, oscar.Unmarshal(&snacFrame, flapBuf))
+			assert.Equal(t, tc.output.Frame, snacFrame)
+
+			// verify the SNAC message
+			snacBuf := &bytes.Buffer{}
+			assert.NoError(t, oscar.Marshal(tc.output.Body, snacBuf))
+			assert.Equal(t, snacBuf.Bytes(), flapBuf.Bytes())
+		})
+	}
+}
+
+func TestNewBuddyRouter(t *testing.T) {
+	type args struct {
+		logger       *slog.Logger
+		buddyHandler BuddyHandler
+	}
+	tests := []struct {
+		name string
+		args args
+		want BuddyRouter
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equalf(t, tt.want, NewBuddyRouter(tt.args.logger, tt.args.buddyHandler), "NewBuddyRouter(%v, %v)", tt.args.logger, tt.args.buddyHandler)
+		})
+	}
+}

server/chat_nav_test.go

@@ -125,12 +125,7 @@ func TestChatNavRouter_RouteChatNavRouter(t *testing.T) {
 				Return(tc.output, tc.handlerErr).
 				Maybe()
 
-			router := ChatNavRouter{
-				ChatNavHandler: svc,
-				RouteLogger: RouteLogger{
-					Logger: NewLogger(Config{}),
-				},
-			}
+			router := NewChatNavRouter(svc, NewLogger(Config{}))
 
 			bufIn := &bytes.Buffer{}
 			assert.NoError(t, oscar.Marshal(tc.input.Body, bufIn))

server/feedbag_test.go

@@ -268,12 +268,7 @@ func TestFeedbagRouter_RouteFeedbag(t *testing.T) {
 				StartClusterHandler(mock.Anything, tc.input.Frame, tc.input.Body).
 				Maybe()
 
-			router := FeedbagRouter{
-				FeedbagHandler: svc,
-				RouteLogger: RouteLogger{
-					Logger: NewLogger(Config{}),
-				},
-			}
+			router := NewFeedbagRouter(NewLogger(Config{}), svc)
 
 			bufIn := &bytes.Buffer{}
 			assert.NoError(t, oscar.Marshal(tc.input.Body, bufIn))

server/icbm_test.go

@@ -171,12 +171,7 @@ func TestICBMRouter_RouteICBM(t *testing.T) {
 					Maybe()
 			}
 
-			router := ICBMRouter{
-				ICBMHandler: svc,
-				RouteLogger: RouteLogger{
-					Logger: NewLogger(Config{}),
-				},
-			}
+			router := NewICBMRouter(NewLogger(Config{}), svc)
 
 			bufIn := &bytes.Buffer{}
 			assert.NoError(t, oscar.Marshal(tc.input.Body, bufIn))

server/locate_test.go

@@ -207,12 +207,7 @@ func TestLocateRouter_RouteLocate(t *testing.T) {
 				Return(tc.output, tc.handlerErr).
 				Maybe()
 
-			router := LocateRouter{
-				LocateHandler: svc,
-				RouteLogger: RouteLogger{
-					Logger: NewLogger(Config{}),
-				},
-			}
+			router := NewLocateRouter(svc, NewLogger(Config{}))
 
 			bufIn := &bytes.Buffer{}
 			assert.NoError(t, oscar.Marshal(tc.input.Body, bufIn))

server/oservice_test.go

@@ -252,15 +252,7 @@ func TestOServiceRouter_RouteOService_ForBOS(t *testing.T) {
 				Return(tc.handlerErr).
 				Maybe()
 
-			router := OServiceBOSRouter{
-				OServiceRouter: OServiceRouter{
-					OServiceHandler: svc,
-					RouteLogger: RouteLogger{
-						Logger: NewLogger(Config{}),
-					},
-				},
-				OServiceBOSHandler: svcBOS,
-			}
+			router := NewOServiceRouterForBOS(NewLogger(Config{}), svc, svcBOS)
 
 			bufIn := &bytes.Buffer{}
 			assert.NoError(t, oscar.Marshal(tc.input.Body, bufIn))
@@ -538,15 +530,7 @@ func TestOServiceRouter_RouteOService_ForChat(t *testing.T) {
 				Return(tc.handlerErr).
 				Maybe()
 
-			router := OServiceChatRouter{
-				OServiceRouter: OServiceRouter{
-					OServiceHandler: svc,
-					RouteLogger: RouteLogger{
-						Logger: NewLogger(Config{}),
-					},
-				},
-				OServiceChatHandler: svcBOS,
-			}
+			router := NewOServiceRouterForChat(NewLogger(Config{}), svc, svcBOS)
 
 			bufIn := &bytes.Buffer{}
 			assert.NoError(t, oscar.Marshal(tc.input.Body, bufIn))