dcbot/internal/domain/group_test.go

package domain_test

import (
	"testing"

	"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
	"github.com/stretchr/testify/assert"
	"golang.org/x/text/language"
)

func TestNewCreateGroupParams(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name          string
		serverID      string
		versionCode   string
		serverKey     string
		languageTag   string
		channelGains  string
		channelLosses string
		barbarians    bool
		internals     bool
		err           error
	}{
		{
			name:          "OK",
			serverID:      "123441",
			versionCode:   "en",
			serverKey:     "en113",
			languageTag:   language.English.String(),
			channelGains:  "1234",
			channelLosses: "1234",
			barbarians:    true,
			internals:     true,
			err:           nil,
		},
		{
			name:        "ERR: ServerID cannot be blank",
			versionCode: "",
			serverID:    "",
			err:         domain.RequiredError{Field: "ServerID"},
		},
		{
			name:        "ERR: VersionCode cannot be blank",
			serverID:    "1234",
			versionCode: "",
			err:         domain.RequiredError{Field: "VersionCode"},
		},
		{
			name:        "ERR: ServerKey cannot be blank",
			serverID:    "1234",
			versionCode: "en",
			serverKey:   "",
			err:         domain.RequiredError{Field: "ServerKey"},
		},
		{
			name:        "ERR: LanguageTag cannot be blank",
			serverID:    "1234",
			versionCode: "en",
			serverKey:   "en113",
			languageTag: "",
			err:         domain.RequiredError{Field: "LanguageTag"},
		},
	}

	for _, tt := range tests {
		tt := tt

		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			res, err := domain.NewCreateGroupParams(
				tt.serverID,
				tt.versionCode,
				tt.serverKey,
				tt.languageTag,
				tt.channelGains,
				tt.channelLosses,
				tt.barbarians,
				tt.internals,
			)
			if tt.err != nil {
				assert.ErrorIs(t, err, tt.err)
				assert.Zero(t, res)
				return
			}
			assert.NoError(t, err)
			assert.Equal(t, tt.serverID, res.ServerID())
			assert.Equal(t, tt.serverKey, res.ServerKey())
			assert.Equal(t, tt.versionCode, res.VersionCode())
			assert.Equal(t, tt.channelGains, res.ChannelGains())
			assert.Equal(t, tt.channelLosses, res.ChannelLosses())
			assert.Equal(t, tt.barbarians, res.Barbarians())
			assert.Equal(t, tt.internals, res.Internals())
		})
	}
}

func TestUpdateGroupParams_IsZero(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name   string
		params domain.UpdateGroupParams
		output bool
	}{
		{
			name: "OK: ChannelGains",
			params: domain.UpdateGroupParams{
				ChannelGains: domain.NullString{
					String: "123",
					Valid:  true,
				},
			},
			output: false,
		},
		{
			name: "OK: ChannelLosses",
			params: domain.UpdateGroupParams{
				ChannelLosses: domain.NullString{
					String: "123",
					Valid:  true,
				},
			},
			output: false,
		},
		{
			name: "OK: Barbarians",
			params: domain.UpdateGroupParams{
				Barbarians: domain.NullBool{
					Bool:  false,
					Valid: true,
				},
			},
			output: false,
		},
		{
			name: "OK: Internals",
			params: domain.UpdateGroupParams{
				Internals: domain.NullBool{
					Bool:  false,
					Valid: true,
				},
			},
			output: false,
		},
		{
			name: "OK: LanguageTag",
			params: domain.UpdateGroupParams{
				LanguageTag: domain.NullString{
					String: language.English.String(),
					Valid:  true,
				},
			},
			output: false,
		},
		{
			name:   "OK: empty struct",
			params: domain.UpdateGroupParams{},
			output: true,
		},
	}

	for _, tt := range tests {
		tt := tt

		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			assert.Equal(t, tt.output, tt.params.IsZero())
		})
	}
}