Skip to content

GOWA - WhatsApp REST API with support for UI, Multi Account, Webhooks, and MCP, and Chatwoot. Built with Golang for efficient memory use.

7.8 KB
Raw Blame
package validations

import (
	"context"
	"testing"

	domainChat "github.com/aldinokemal/go-whatsapp-web-multidevice/domains/chat"
	pkgError "github.com/aldinokemal/go-whatsapp-web-multidevice/pkg/error"
	"github.com/stretchr/testify/assert"
)

func TestValidateListChats(t *testing.T) {
	type args struct {
		request domainChat.ListChatsRequest
	}
	tests := []struct {
		name string
		args args
		err  any
	}{
		{
			name: "should success with valid request",
			args: args{request: domainChat.ListChatsRequest{
				Limit:  25,
				Offset: 0,
			}},
			err: nil,
		},
		{
			name: "should success with zero limit (auto set to default)",
			args: args{request: domainChat.ListChatsRequest{
				Limit:  0,
				Offset: 0,
			}},
			err: nil,
		},
		{
			name: "should success with max limit",
			args: args{request: domainChat.ListChatsRequest{
				Limit:  100,
				Offset: 50,
			}},
			err: nil,
		},
		{
			name: "should error with limit too high",
			args: args{request: domainChat.ListChatsRequest{
				Limit:  101,
				Offset: 0,
			}},
			err: pkgError.ValidationError("limit: must be no greater than 100."),
		},
		{
			name: "should error with negative offset",
			args: args{request: domainChat.ListChatsRequest{
				Limit:  25,
				Offset: -1,
			}},
			err: pkgError.ValidationError("offset: must be no less than 0."),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateListChats(context.Background(), &tt.args.request)
			assert.Equal(t, tt.err, err)
		})
	}
}

func TestValidateGetChatMessages(t *testing.T) {
	type args struct {
		request domainChat.GetChatMessagesRequest
	}
	tests := []struct {
		name string
		args args
		err  any
	}{
		{
			name: "should success with valid request",
			args: args{request: domainChat.GetChatMessagesRequest{
				ChatJID: "[email protected]",
				Limit:   50,
				Offset:  0,
			}},
			err: nil,
		},
		{
			name: "should success with zero limit (auto set to default)",
			args: args{request: domainChat.GetChatMessagesRequest{
				ChatJID: "[email protected]",
				Limit:   0,
				Offset:  0,
			}},
			err: nil,
		},
		{
			name: "should success with max limit",
			args: args{request: domainChat.GetChatMessagesRequest{
				ChatJID: "[email protected]",
				Limit:   100,
				Offset:  50,
			}},
			err: nil,
		},
		{
			name: "should error with empty chat_jid",
			args: args{request: domainChat.GetChatMessagesRequest{
				ChatJID: "",
				Limit:   50,
				Offset:  0,
			}},
			err: pkgError.ValidationError("chat_jid: cannot be blank."),
		},
		{
			name: "should error with limit too high",
			args: args{request: domainChat.GetChatMessagesRequest{
				ChatJID: "[email protected]",
				Limit:   101,
				Offset:  0,
			}},
			err: pkgError.ValidationError("limit: must be no greater than 100."),
		},
		{
			name: "should error with negative offset",
			args: args{request: domainChat.GetChatMessagesRequest{
				ChatJID: "[email protected]",
				Limit:   50,
				Offset:  -1,
			}},
			err: pkgError.ValidationError("offset: must be no less than 0."),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateGetChatMessages(context.Background(), &tt.args.request)
			assert.Equal(t, tt.err, err)
		})
	}
}

func TestValidatePinChat(t *testing.T) {
	type args struct {
		request domainChat.PinChatRequest
	}
	tests := []struct {
		name string
		args args
		err  any
	}{
		{
			name: "should success with valid request",
			args: args{request: domainChat.PinChatRequest{
				ChatJID: "[email protected]",
				Pinned:  true,
			}},
			err: nil,
		},
		{
			name: "should success with unpin request",
			args: args{request: domainChat.PinChatRequest{
				ChatJID: "[email protected]",
				Pinned:  false,
			}},
			err: nil,
		},
		{
			name: "should error with empty chat_jid",
			args: args{request: domainChat.PinChatRequest{
				ChatJID: "",
				Pinned:  true,
			}},
			err: pkgError.ValidationError("chat_jid: cannot be blank."),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidatePinChat(context.Background(), &tt.args.request)
			assert.Equal(t, tt.err, err)
		})
	}
}

func TestValidateSetDisappearingTimer(t *testing.T) {
	type args struct {
		request domainChat.SetDisappearingTimerRequest
	}
	tests := []struct {
		name string
		args args
		err  any
	}{
		{
			name: "should success with timer disabled (0)",
			args: args{request: domainChat.SetDisappearingTimerRequest{
				ChatJID:      "[email protected]",
				TimerSeconds: 0,
			}},
			err: nil,
		},
		{
			name: "should success with 24 hours timer",
			args: args{request: domainChat.SetDisappearingTimerRequest{
				ChatJID:      "[email protected]",
				TimerSeconds: 86400,
			}},
			err: nil,
		},
		{
			name: "should success with 7 days timer",
			args: args{request: domainChat.SetDisappearingTimerRequest{
				ChatJID:      "[email protected]",
				TimerSeconds: 604800,
			}},
			err: nil,
		},
		{
			name: "should success with 90 days timer",
			args: args{request: domainChat.SetDisappearingTimerRequest{
				ChatJID:      "[email protected]",
				TimerSeconds: 7776000,
			}},
			err: nil,
		},
		{
			name: "should error with empty chat_jid",
			args: args{request: domainChat.SetDisappearingTimerRequest{
				ChatJID:      "",
				TimerSeconds: 86400,
			}},
			err: pkgError.ValidationError("chat_jid: cannot be blank."),
		},
		{
			name: "should error with invalid timer value",
			args: args{request: domainChat.SetDisappearingTimerRequest{
				ChatJID:      "[email protected]",
				TimerSeconds: 12345,
			}},
			err: pkgError.ValidationError("timer_seconds: timer_seconds must be one of: 0 (off), 86400 (24h), 604800 (7d), 7776000 (90d)."),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateSetDisappearingTimer(context.Background(), &tt.args.request)
			assert.Equal(t, tt.err, err)
		})
	}
}

func TestValidateRequestChatHistory(t *testing.T) {
	type args struct {
		request domainChat.RequestChatHistoryRequest
	}
	tests := []struct {
		name          string
		args          args
		err           any
		expectedCount int
	}{
		{
			name: "should success with valid request",
			args: args{request: domainChat.RequestChatHistoryRequest{
				ChatJID: "[email protected]",
				Count:   100,
			}},
			err:           nil,
			expectedCount: 100,
		},
		{
			name: "should default count to 50 when zero",
			args: args{request: domainChat.RequestChatHistoryRequest{
				ChatJID: "[email protected]",
				Count:   0,
			}},
			err:           nil,
			expectedCount: 50,
		},
		{
			name: "should success with max count",
			args: args{request: domainChat.RequestChatHistoryRequest{
				ChatJID: "[email protected]",
				Count:   500,
			}},
			err:           nil,
			expectedCount: 500,
		},
		{
			name: "should error with empty chat_jid",
			args: args{request: domainChat.RequestChatHistoryRequest{
				ChatJID: "",
				Count:   50,
			}},
			err: pkgError.ValidationError("chat_jid: cannot be blank."),
		},
		{
			name: "should error with count above cap",
			args: args{request: domainChat.RequestChatHistoryRequest{
				ChatJID: "[email protected]",
				Count:   501,
			}},
			err: pkgError.ValidationError("count: must be no greater than 500."),
		},
		{
			name: "should error with negative count",
			args: args{request: domainChat.RequestChatHistoryRequest{
				ChatJID: "[email protected]",
				Count:   -1,
			}},
			err: pkgError.ValidationError("count: must be no less than 1."),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			err := ValidateRequestChatHistory(context.Background(), &tt.args.request)
			assert.Equal(t, tt.err, err)
			if tt.err == nil {
				assert.Equal(t, tt.expectedCount, tt.args.request.Count)
			}
		})
	}
}