19743981475

Committed 27 Nov 2025 05:26PM UTC coverage: 72.203% (-0.007%) from 72.21%

Build # 19743981475

Build Type

push

github

Committed by

et-nik

Commit Message

fix tests

Run Details

9 of 11 new or added lines in 2 files covered. (81.82%)

33 existing lines in 3 files now uncovered.

24962 of 34572 relevant lines covered (72.2%)

380.66 hits per line

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

77.05

/internal/api/nodes/postnode/handler.go

package postnode

import (
        "context"
        "encoding/json"
        "net/http"
        "path/filepath"
        "time"

        "github.com/gameap/gameap/internal/api/base"
        "github.com/gameap/gameap/internal/domain"
        "github.com/gameap/gameap/internal/files"
        "github.com/gameap/gameap/internal/repositories"
        "github.com/gameap/gameap/pkg/strings"
        "github.com/pkg/errors"
        "github.com/rs/xid"
)

const (
        apiKeyLength     = 32
        certificatesPath = "certs"
)

var (
        ErrFailedToGenerateAPIKey  = errors.New("failed to generate API key")
        ErrFailedToSaveCertificate = errors.New("failed to save certificate")
        ErrFailedToSaveNode        = errors.New("failed to save node")
)

type Handler struct {
        repo        repositories.NodeRepository
        fileManager files.FileManager
        responder   base.Responder
}

func NewHandler(
        repo repositories.NodeRepository,
        fileManager files.FileManager,
        responder base.Responder,
) *Handler {
        return &Handler{
                repo:        repo,
                fileManager: fileManager,
                responder:   responder,
        }
}

func (h *Handler) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
        ctx := r.Context()

        input := &createDedicatedServerInput{}

        err := json.NewDecoder(r.Body).Decode(&input)
        if err != nil {
                h.responder.WriteError(ctx, rw, errors.WithMessage(err, "invalid request"))

                return
        }

        err = input.Validate()
        if err != nil {
                h.responder.WriteError(ctx, rw, errors.WithMessage(err, "validation failed"))

                return
        }

        node, err := h.createNode(ctx, input)
        if err != nil {
                h.responder.WriteError(ctx, rw, errors.WithMessage(err, "failed to create dedicated server"))

                return
        }

        response := newDedicatedServerResponse(node)
        rw.WriteHeader(http.StatusCreated)
        h.responder.Write(ctx, rw, response)
}

func (h *Handler) createNode(ctx context.Context, input *createDedicatedServerInput) (*domain.Node, error) {
        if input.GdaemonServerCert == "" {
                return nil, ErrCertificateRequired
        }

        certXID := xid.New().String()
        certPath := filepath.Join(certificatesPath, certXID+".crt")

        if err := h.fileManager.Write(ctx, certPath, []byte(input.GdaemonServerCert)); err != nil {
                return nil, errors.WithMessage(ErrFailedToSaveCertificate, err.Error())
        }

        apiKey, err := strings.CryptoRandomString(apiKeyLength)
        if err != nil {
                _ = h.fileManager.Delete(ctx, certPath)

                return nil, errors.WithMessage(ErrFailedToGenerateAPIKey, err.Error())
        }

        node := input.ToDomain(apiKey, certPath)

        now := time.Now()
        node.CreatedAt = &now
        node.UpdatedAt = &now

        if err := h.repo.Save(ctx, node); err != nil {
                _ = h.fileManager.Delete(ctx, certPath)

                return nil, errors.WithMessage(ErrFailedToSaveNode, err.Error())
        }

        return node, nil
}

1	package postnode
2
3	import (
4	"context"
5	"encoding/json"
6	"net/http"
7	"path/filepath"
8	"time"
9
10	"github.com/gameap/gameap/internal/api/base"
11	"github.com/gameap/gameap/internal/domain"
12	"github.com/gameap/gameap/internal/files"
13	"github.com/gameap/gameap/internal/repositories"
14	"github.com/gameap/gameap/pkg/strings"
15	"github.com/pkg/errors"
16	"github.com/rs/xid"
17	)
18
19	const (
20	apiKeyLength = 32
21	certificatesPath = "certs"
22	)
23
24	var (
25	ErrFailedToGenerateAPIKey = errors.New("failed to generate API key")
26	ErrFailedToSaveCertificate = errors.New("failed to save certificate")
27	ErrFailedToSaveNode = errors.New("failed to save node")
28	)
29
30	type Handler struct {
31	repo repositories.NodeRepository
32	fileManager files.FileManager
33	responder base.Responder
34	}
35
36	func NewHandler(
37	repo repositories.NodeRepository,
38	fileManager files.FileManager,
39	responder base.Responder,
40	) *Handler {	20✔
41	return &Handler{	20✔
42	repo: repo,	20✔
43	fileManager: fileManager,	20✔
44	responder: responder,	20✔
45	}	20✔
46	}	20✔
47
48	func (h Handler) ServeHTTP(rw http.ResponseWriter, r http.Request) {	20✔
49	ctx := r.Context()	20✔
50		20✔
51	input := &createDedicatedServerInput{}	20✔
52		20✔
53	err := json.NewDecoder(r.Body).Decode(&input)	20✔
54	if err != nil {	20✔
UNCOV 55	h.responder.WriteError(ctx, rw, errors.WithMessage(err, "invalid request"))	×
UNCOV 56		×
UNCOV 57	return	×
58	}	×
59
60	err = input.Validate()	20✔
61	if err != nil {	32✔
62	h.responder.WriteError(ctx, rw, errors.WithMessage(err, "validation failed"))	12✔
63		12✔
64	return	12✔
65	}	12✔
66
67	node, err := h.createNode(ctx, input)	8✔
68	if err != nil {	9✔
69	h.responder.WriteError(ctx, rw, errors.WithMessage(err, "failed to create dedicated server"))	1✔
70		1✔
71	return	1✔
72	}	1✔
73
74	response := newDedicatedServerResponse(node)	7✔
75	rw.WriteHeader(http.StatusCreated)	7✔
76	h.responder.Write(ctx, rw, response)	7✔
77	}
78
79	func (h Handler) createNode(ctx context.Context, input createDedicatedServerInput) (*domain.Node, error) {	8✔
80	if input.GdaemonServerCert == "" {	8✔
UNCOV 81	return nil, ErrCertificateRequired	×
UNCOV 82	}	×
83
84	certXID := xid.New().String()	8✔
85	certPath := filepath.Join(certificatesPath, certXID+".crt")	8✔
86		8✔
87	if err := h.fileManager.Write(ctx, certPath, []byte(input.GdaemonServerCert)); err != nil {	9✔
88	return nil, errors.WithMessage(ErrFailedToSaveCertificate, err.Error())	1✔
89	}	1✔
90
91	apiKey, err := strings.CryptoRandomString(apiKeyLength)	7✔
92	if err != nil {	7✔
UNCOV 93	_ = h.fileManager.Delete(ctx, certPath)	×
UNCOV 94		×
UNCOV 95	return nil, errors.WithMessage(ErrFailedToGenerateAPIKey, err.Error())	×
96	}	×
97
98	node := input.ToDomain(apiKey, certPath)	7✔
99		7✔
100	now := time.Now()	7✔
101	node.CreatedAt = &now	7✔
102	node.UpdatedAt = &now	7✔
103		7✔
104	if err := h.repo.Save(ctx, node); err != nil {	7✔
UNCOV 105	_ = h.fileManager.Delete(ctx, certPath)	×
UNCOV 106		×
UNCOV 107	return nil, errors.WithMessage(ErrFailedToSaveNode, err.Error())	×
108	}	×
109
110	return node, nil	7✔
111	}

gameap / gameap / 19743981475

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