feat: added WithBotIDs and validation for WithBotUserIDs

Author: trakhimenok

botsfwmodels/platform_user_data.go

@@ -6,7 +6,7 @@ var _ PlatformUserData = (*PlatformUserBaseDbo)(nil)
 type PlatformUserBaseDbo struct {
 	BotBaseData
 
-	BotIDs []string `json:"botIDs,omitempty" dalgo:"botIDs,omitempty,noindex" firestore:"botIDs,omitempty"`
+	WithRequiredBotIDs
 
 	// FirstName is the first name of a user
 	FirstName string `json:"firstName,omitempty" dalgo:"firstName,omitempty,noindex" firestore:"firstName,omitempty"`
@@ -22,3 +22,13 @@ type PlatformUserBaseDbo struct {
 func (v *PlatformUserBaseDbo) BaseData() *PlatformUserBaseDbo {
 	return v
 }
+
+func (v *PlatformUserBaseDbo) Validate() error {
+	if err := v.BotBaseData.Validate(); err != nil {
+		return err
+	}
+	if err := v.WithRequiredBotIDs.Validate(); err != nil {
+		return err
+	}
+	return nil
+}

botsfwmodels/with_bot_ids.go

@@ -0,0 +1,29 @@
+package botsfwmodels
+
+import (
+	"fmt"
+	"github.com/strongo/validation"
+	"strings"
+)
+
+type WithBotIDs struct {
+	BotIDs []string `json:"botIDs,omitempty" dalgo:"botIDs,omitempty,noindex" firestore:"botIDs,omitempty"`
+}
+
+func (v WithBotIDs) Validate() error {
+	for i, botID := range v.BotIDs {
+		if strings.TrimSpace(botID) == "" {
+			return validation.NewErrBadRecordFieldValue(fmt.Sprintf("botIDs[%d]", i), "is empty")
+		}
+	}
+	return nil
+}
+
+type WithRequiredBotIDs WithBotIDs
+
+func (v WithRequiredBotIDs) Validate() error {
+	if len(v.BotIDs) == 0 {
+		return validation.NewErrRecordIsMissingRequiredField("botIDs")
+	}
+	return WithBotIDs(v).Validate()
+}

botsfwmodels/with_bot_ids_test.go

@@ -0,0 +1,90 @@
+package botsfwmodels
+
+import (
+	"github.com/strongo/validation"
+	"testing"
+)
+
+func TestWithBotIDs_Validate(t *testing.T) {
+	type fields struct {
+		BotIDs []string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr bool
+	}{
+		{
+			name: "Should pass for good records",
+			fields: fields{
+				BotIDs: []string{"bot1", "bot2", "bot3"},
+			},
+			wantErr: false,
+		},
+		{
+			name: "Should pass for nil",
+			fields: fields{
+				BotIDs: []string{"bot1"},
+			},
+			wantErr: false,
+		},
+		{
+			name: "Should pass for empty",
+			fields: fields{
+				BotIDs: []string{"bot1"},
+			},
+			wantErr: false,
+		},
+		{
+			name: "Should fail for non trimmed",
+			fields: fields{
+				BotIDs: []string{" bot1"},
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := WithBotIDs{
+				BotIDs: tt.fields.BotIDs,
+			}
+			if err := v.Validate(); (err != nil) != tt.wantErr {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestWithRequiredBotIDs_Validate(t *testing.T) {
+	tests := []struct {
+		name    string
+		v       WithRequiredBotIDs
+		wantErr bool
+	}{
+		{
+			name: "Should pass",
+			v: WithRequiredBotIDs{
+				BotIDs: []string{"bot1"},
+			},
+			wantErr: false,
+		},
+		{
+			name:    "Should fail on nil",
+			v:       WithRequiredBotIDs{BotIDs: []string{}},
+			wantErr: true,
+		},
+		{
+			name:    "Should fail on empty",
+			v:       WithRequiredBotIDs{BotIDs: []string{}},
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.v.Validate()
+			if err == nil && tt.wantErr || err != nil && !tt.wantErr || tt.wantErr && !validation.IsBadFieldValueError(err) {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

botsfwmodels/with_bot_user_ids.go

@@ -2,17 +2,41 @@ package botsfwmodels
 
 import (
 	"fmt"
+	"github.com/strongo/validation"
 	"slices"
+	"strings"
 )
 
 type WithBotUserIDs struct {
 	BotUserIDs []string `json:"botUserIDs,omitempty" firestore:"botUserIDs,omitempty" dalgo:"botUserIDs,omitempty"`
 }
 
 func (v *WithBotUserIDs) SetBotUserID(platform, bot, userID string) {
+	if pid := strings.TrimSpace(platform); pid == "" {
+		panic("value of `platform` argument is empty")
+	} else if pid != platform {
+		panic("value of `platform` argument is not trimmed")
+	}
+	if bid := strings.TrimSpace(bot); bid != bot {
+		panic("value of `bot` argument is not trimmed")
+	}
+	if uid := strings.TrimSpace(userID); uid == "" {
+		panic("value of `platform` argument is empty")
+	} else if uid != userID {
+		panic("value of `userID` argument is not trimmed")
+	}
 	botUserID := fmt.Sprintf("%s:%s:%s", platform, bot, userID)
 	if slices.Contains(v.BotUserIDs, botUserID) {
 		return
 	}
 	v.BotUserIDs = append(v.BotUserIDs, botUserID)
 }
+
+func (v *WithBotUserIDs) Validate() error {
+	for i, botUserID := range v.BotUserIDs {
+		if strings.TrimSpace(botUserID) == "" {
+			return validation.NewErrBadRecordFieldValue(fmt.Sprintf("botUserIDs[%d]", i), "is empty")
+		}
+	}
+	return nil
+}

botsfwmodels/with_bot_user_ids_test.go

@@ -0,0 +1,107 @@
+package botsfwmodels
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestWithBotUserIDs_SetBotUserID(t *testing.T) {
+	type fields struct {
+		BotUserIDs []string
+	}
+	type args struct {
+		platform string
+		bot      string
+		userID   string
+	}
+	tests := []struct {
+		name          string
+		fields        fields
+		args          args
+		expectedPanic string
+	}{
+		{
+			name:   "Should pass",
+			fields: fields{BotUserIDs: []string{"platform1:bot1:user1"}},
+			args:   args{platform: "platform2", bot: "bot2", userID: "user2"},
+		},
+		{
+			name:          "Should panic when platform is empty",
+			args:          args{platform: " ", bot: "bot2", userID: "user2"},
+			expectedPanic: "value of `platform` argument is empty",
+		},
+		{
+			name:          "Should panic when platform has space at start",
+			args:          args{platform: " p1", bot: "bot2", userID: "user2"},
+			expectedPanic: "value of `platform` argument is not trimmed",
+		},
+		{
+			name:          "Should panic when platform has space at end",
+			args:          args{platform: "p1 ", bot: "bot2", userID: "user2"},
+			expectedPanic: "value of `platform` argument is not trimmed",
+		},
+		{
+			name: "Should pass when bot is empty",
+			args: args{platform: "platform", bot: "", userID: "user2"},
+		},
+		{
+			name:          "Should panic when bot has only spaces",
+			args:          args{platform: "platform", bot: " ", userID: "user2"},
+			expectedPanic: "value of `bot` argument is not trimmed",
+		},
+		{
+			name:          "Should panic when bot has space at start",
+			args:          args{platform: "platform", bot: " bot2", userID: "user2"},
+			expectedPanic: "value of `bot` argument is not trimmed",
+		},
+		{
+			name:          "Should panic when bot has space at end",
+			args:          args{platform: "bot", bot: "bot2 ", userID: "user2"},
+			expectedPanic: "value of `bot` argument is not trimmed",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := &WithBotUserIDs{
+				BotUserIDs: tt.fields.BotUserIDs,
+			}
+			if tt.expectedPanic != "" {
+				defer func() {
+					if r := recover(); r == nil || r.(string) != tt.expectedPanic {
+						t.Errorf("SetBotUserID() panic = %v, expected: %v", r, tt.expectedPanic)
+					}
+				}()
+			}
+			v.SetBotUserID(tt.args.platform, tt.args.bot, tt.args.userID)
+		})
+	}
+}
+
+func TestWithBotUserIDs_Validate(t *testing.T) {
+	type fields struct {
+		BotUserIDs []string
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		wantErr error
+	}{
+		{
+			name: "Should pass",
+			fields: fields{
+				BotUserIDs: []string{"platform1:bot1:user1"},
+			},
+			wantErr: nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			v := &WithBotUserIDs{
+				BotUserIDs: tt.fields.BotUserIDs,
+			}
+			if err := v.Validate(); err == nil && tt.wantErr != nil || tt.wantErr == nil && err != nil || !errors.Is(err, tt.wantErr) {
+				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}