dcbot/internal/domain/group_test.go

package domain_test

import (
	"fmt"
	"testing"

	"gitea.dwysokinski.me/twhelp/dcbot/internal/domain"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
)

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

	tests := []struct {
		name          string
		serverID      string
		versionCode   string
		serverKey     string
		channelGains  string
		channelLosses string
		barbarians    bool
		internals     bool
		err           error
	}{
		{
			name:          "OK",
			serverID:      "123441",
			versionCode:   "en",
			serverKey:     "en113",
			channelGains:  "1234",
			channelLosses: "1234",
			barbarians:    true,
			internals:     true,
			err:           nil,
		},
		{
			name:        "ERR: ServerID cannot be blank",
			versionCode: "",
			serverID:    "",
			err: domain.ValidationError{
				Field: "ServerID",
				Err:   domain.ErrRequired,
			},
		},
		{
			name:        "ERR: VersionCode cannot be blank",
			serverID:    "1234",
			versionCode: "",
			err: domain.ValidationError{
				Field: "VersionCode",
				Err:   domain.ErrRequired,
			},
		},
		{
			name:        "ERR: ServerKey cannot be blank",
			serverID:    "1234",
			versionCode: "en",
			serverKey:   "",
			err: domain.ValidationError{
				Field: "ServerKey",
				Err:   domain.ErrRequired,
			},
		},
	}

	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.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: all",
			params: domain.UpdateGroupParams{
				ChannelGains: domain.NullString{
					String: "123",
					Valid:  true,
				},
				ChannelLosses: domain.NullString{
					String: "123",
					Valid:  true,
				},
				Barbarians: domain.NullBool{
					Bool:  false,
					Valid: true,
				},
				Internals: domain.NullBool{
					Bool:  false,
					Valid: true,
				},
			},
			output: false,
		},
		{
			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: 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())
		})
	}
}

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

	err := domain.GroupLimitReachedError{
		Current: 10,
		Limit:   10,
	}
	var _ domain.Error = err
	assert.Equal(t, fmt.Sprintf("group limit has been reached (%d/%d)", err.Current, err.Limit), err.Error())
	assert.Equal(t, err.Error(), err.UserError())
	assert.Equal(t, domain.ErrorCodeValidationError, err.Code())
}

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

	err := domain.GroupNotFoundError{
		ID: uuid.NewString(),
	}
	var _ domain.Error = err
	assert.Equal(t, fmt.Sprintf("group (ID=%s) not found", err.ID), err.Error())
	assert.Equal(t, err.Error(), err.UserError())
	assert.Equal(t, domain.ErrorCodeEntityNotFound, err.Code())
}

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

	err := domain.GroupDoesNotExistError{
		ID: uuid.NewString(),
	}
	var _ domain.Error = err
	assert.Equal(t, fmt.Sprintf("group (ID=%s) doesn't exist", err.ID), err.Error())
	assert.Equal(t, err.Error(), err.UserError())
	assert.Equal(t, domain.ErrorCodeValidationError, err.Code())
}