19746581946

Committed 27 Nov 2025 07:48PM UTC coverage: 72.247% (+0.04%) from 72.203%

Build # 19746581946

Build Type

push

github

Committed by

et-nik

Commit Message

flexible types

Run Details

126 of 143 new or added lines in 16 files covered. (88.11%)

2 existing lines in 1 file now uncovered.

25051 of 34674 relevant lines covered (72.25%)

379.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.2

/internal/api/users/postusers/input.go

package postusers

import (
        "fmt"
        "strings"

        "github.com/gameap/gameap/internal/domain"
        "github.com/gameap/gameap/pkg/api"
        "github.com/gameap/gameap/pkg/auth"
        "github.com/gameap/gameap/pkg/flexible"
        "github.com/gameap/gameap/pkg/validation"
        "github.com/pkg/errors"
)

const (
        maxLoginLength    = 255
        maxEmailLength    = 255
        maxNameLength     = 255
        minPasswordLength = 8
        maxPasswordLength = 64
)

var (
        ErrLoginRequired    = api.NewValidationError("login is required")
        ErrEmailRequired    = api.NewValidationError("email is required")
        ErrPasswordRequired = api.NewValidationError("password is required")
        ErrLoginTooLong     = api.NewValidationError(
                fmt.Sprintf("login must not exceed %d characters", maxLoginLength),
        )
        ErrEmailTooLong = api.NewValidationError(
                fmt.Sprintf("email must not exceed %d characters", maxEmailLength),
        )
        ErrNameTooLong = api.NewValidationError(
                fmt.Sprintf("name must not exceed %d characters", maxNameLength),
        )
        ErrPasswordTooShort = api.NewValidationError(
                fmt.Sprintf("password must be at least %d characters long", minPasswordLength),
        )
        ErrPasswordTooLong = api.NewValidationError(
                fmt.Sprintf("password must not exceed %d characters", maxPasswordLength),
        )
        ErrInvalidEmail = api.NewValidationError("email is not valid")
        ErrLoginEmpty   = api.NewValidationError("login cannot be empty")
        ErrEmailEmpty   = api.NewValidationError("email cannot be empty")
        ErrNameEmpty    = api.NewValidationError("name cannot be empty")
)

type createUserInput struct {
        Login    string          `json:"login"`
        Email    string          `json:"email"`
        Password string          `json:"password"`
        Name     *string         `json:"name,omitempty"`
        Roles    []string        `json:"roles"`
        Servers  []flexible.Uint `json:"servers"`
}

func (input *createUserInput) Validate() error {
        if input.Login == "" {
                return ErrLoginRequired
        }

        loginValue := strings.TrimSpace(input.Login)
        if loginValue == "" {
                return ErrLoginEmpty
        }

        if len(loginValue) > maxLoginLength {
                return ErrLoginTooLong
        }

        input.Login = loginValue

        if input.Email == "" {
                return ErrEmailRequired
        }

        emailValue := strings.TrimSpace(input.Email)
        if emailValue == "" {
                return ErrEmailEmpty
        }

        if len(emailValue) > maxEmailLength {
                return ErrEmailTooLong
        }

        if !validation.IsEmail(emailValue) {
                return ErrInvalidEmail
        }

        input.Email = emailValue

        if input.Password == "" {
                return ErrPasswordRequired
        }

        if len(input.Password) < minPasswordLength {
                return ErrPasswordTooShort
        }

        if len(input.Password) > maxPasswordLength {
                return ErrPasswordTooLong
        }

        if input.Name != nil {
                nameValue := strings.TrimSpace(*input.Name)
                if nameValue == "" {
                        return ErrNameEmpty
                }

                if len(nameValue) > maxNameLength {
                        return ErrNameTooLong
                }

                input.Name = &nameValue
        }

        return nil
}

func (input *createUserInput) ToDomain() (*domain.User, error) {
        hashedPassword, err := auth.HashPassword(strings.TrimSpace(input.Password))
        if err != nil {
                return nil, errors.WithMessage(err, "failed to hash password")
        }

        var name *string
        if input.Name != nil {
                nameValue := strings.TrimSpace(*input.Name)
                name = &nameValue
        }

        return &domain.User{
                Login:    strings.TrimSpace(input.Login),
                Email:    strings.TrimSpace(input.Email),
                Password: hashedPassword,
                Name:     name,
        }, nil
}

func (input *createUserInput) ServerIDs() []uint {
        result := make([]uint, 0, len(input.Servers))
        for _, s := range input.Servers {
                result = append(result, s.Uint())
        }

        return result
}

1	package postusers
2
3	import (
4	"fmt"
5	"strings"
6
7	"github.com/gameap/gameap/internal/domain"
8	"github.com/gameap/gameap/pkg/api"
9	"github.com/gameap/gameap/pkg/auth"
10	"github.com/gameap/gameap/pkg/flexible"
11	"github.com/gameap/gameap/pkg/validation"
12	"github.com/pkg/errors"
13	)
14
15	const (
16	maxLoginLength = 255
17	maxEmailLength = 255
18	maxNameLength = 255
19	minPasswordLength = 8
20	maxPasswordLength = 64
21	)
22
23	var (
24	ErrLoginRequired = api.NewValidationError("login is required")
25	ErrEmailRequired = api.NewValidationError("email is required")
26	ErrPasswordRequired = api.NewValidationError("password is required")
27	ErrLoginTooLong = api.NewValidationError(
28	fmt.Sprintf("login must not exceed %d characters", maxLoginLength),
29	)
30	ErrEmailTooLong = api.NewValidationError(
31	fmt.Sprintf("email must not exceed %d characters", maxEmailLength),
32	)
33	ErrNameTooLong = api.NewValidationError(
34	fmt.Sprintf("name must not exceed %d characters", maxNameLength),
35	)
36	ErrPasswordTooShort = api.NewValidationError(
37	fmt.Sprintf("password must be at least %d characters long", minPasswordLength),
38	)
39	ErrPasswordTooLong = api.NewValidationError(
40	fmt.Sprintf("password must not exceed %d characters", maxPasswordLength),
41	)
42	ErrInvalidEmail = api.NewValidationError("email is not valid")
43	ErrLoginEmpty = api.NewValidationError("login cannot be empty")
44	ErrEmailEmpty = api.NewValidationError("email cannot be empty")
45	ErrNameEmpty = api.NewValidationError("name cannot be empty")
46	)
47
48	type createUserInput struct {
49	Login string `json:"login"`
50	Email string `json:"email"`
51	Password string `json:"password"`
52	Name *string `json:"name,omitempty"`
53	Roles []string `json:"roles"`
54	Servers []flexible.Uint `json:"servers"`
55	}
56
57	func (input *createUserInput) Validate() error {	17✔
58	if input.Login == "" {	18✔
59	return ErrLoginRequired	1✔
60	}	1✔
61
62	loginValue := strings.TrimSpace(input.Login)	16✔
63	if loginValue == "" {	17✔
64	return ErrLoginEmpty	1✔
65	}	1✔
66
67	if len(loginValue) > maxLoginLength {	16✔
68	return ErrLoginTooLong	1✔
69	}	1✔
70
71	input.Login = loginValue	14✔
72		14✔
73	if input.Email == "" {	15✔
74	return ErrEmailRequired	1✔
75	}	1✔
76
77	emailValue := strings.TrimSpace(input.Email)	13✔
78	if emailValue == "" {	14✔
79	return ErrEmailEmpty	1✔
80	}	1✔
81
82	if len(emailValue) > maxEmailLength {	13✔
83	return ErrEmailTooLong	1✔
84	}	1✔
85
86	if !validation.IsEmail(emailValue) {	12✔
87	return ErrInvalidEmail	1✔
88	}	1✔
89
90	input.Email = emailValue	10✔
91		10✔
92	if input.Password == "" {	11✔
93	return ErrPasswordRequired	1✔
94	}	1✔
95
96	if len(input.Password) < minPasswordLength {	10✔
97	return ErrPasswordTooShort	1✔
98	}	1✔
99
100	if len(input.Password) > maxPasswordLength {	9✔
101	return ErrPasswordTooLong	1✔
102	}	1✔
103
104	if input.Name != nil {	11✔
105	nameValue := strings.TrimSpace(*input.Name)	4✔
106	if nameValue == "" {	5✔
107	return ErrNameEmpty	1✔
108	}	1✔
109
110	if len(nameValue) > maxNameLength {	4✔
111	return ErrNameTooLong	1✔
112	}	1✔
113
114	input.Name = &nameValue	2✔
115	}
116
117	return nil	5✔
118	}
119
120	func (input createUserInput) ToDomain() (domain.User, error) {	3✔
121	hashedPassword, err := auth.HashPassword(strings.TrimSpace(input.Password))	3✔
122	if err != nil {	3✔
123	return nil, errors.WithMessage(err, "failed to hash password")	×
124	}	×
125
126	var name *string	3✔
127	if input.Name != nil {	5✔
128	nameValue := strings.TrimSpace(*input.Name)	2✔
129	name = &nameValue	2✔
130	}	2✔
131
132	return &domain.User{	3✔
133	Login: strings.TrimSpace(input.Login),	3✔
134	Email: strings.TrimSpace(input.Email),	3✔
135	Password: hashedPassword,	3✔
136	Name: name,	3✔
137	}, nil	3✔
138	}
139
140	func (input *createUserInput) ServerIDs() []uint {	3✔
141	result := make([]uint, 0, len(input.Servers))	3✔
142	for _, s := range input.Servers {	3✔
NEW 143	result = append(result, s.Uint())	×
NEW 144	}	×
145
146	return result	3✔
147	}

gameap / gameap / 19746581946

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous