14147634314

Committed 29 Mar 2025 04:57PM UTC coverage: 77.948% (+1.5%) from 76.401%

Build # 14147634314

Build Type

Pull #42

github

Committed by

web-flow

Commit Message

Merge 7b5514434 into 49c2b9b02

Pull Request Pull Request #42: integration test for order service

Coverage Stats

300 of 499 new or added lines in 18 files covered. (60.12%)

9 existing lines in 3 files now uncovered.

4719 of 6054 relevant lines covered (77.95%)

2.08 hits per line

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

80.7

/srv/authenticator/controller/controller.go

package controller

import (
        "context"
        "encoding/json"
        "sync"

        "github.com/alimitedgroup/MVP/common"
        "github.com/alimitedgroup/MVP/common/lib/broker"
        "github.com/alimitedgroup/MVP/common/lib/observability"
        commonauth "github.com/alimitedgroup/MVP/srv/authenticator/authCommon"
        servicecmd "github.com/alimitedgroup/MVP/srv/authenticator/service/cmd"
        serviceportin "github.com/alimitedgroup/MVP/srv/authenticator/service/portIn"
        "github.com/nats-io/nats.go"
        "go.opentelemetry.io/otel/attribute"
        "go.opentelemetry.io/otel/metric"
        "go.uber.org/fx"
        "go.uber.org/zap"
)

var (
        AuthRequests metric.Int64Counter
        Logger       *zap.Logger
        metricMap    sync.Map
)

type MetricParams struct {
        fx.In
        Logger *zap.Logger
        Meter  metric.Meter
}

type authController struct {
        tokenUseCase serviceportin.IGetTokenUseCase
}

func NewAuthController(tokenUseCase serviceportin.IGetTokenUseCase, mp MetricParams) *authController {
        observability.CounterSetup(&mp.Meter, mp.Logger, &AuthRequests, &metricMap, "num_token_requests")
        Logger = mp.Logger
        return &authController{tokenUseCase: tokenUseCase}
}

func (ar *authController) checkGetTokenRequest(dto *common.AuthLoginRequest) error {
        if dto.Username == "" {
                return commonauth.ErrUserNotLegit
        }
        return nil
}

func (ar *authController) NewTokenRequest(ctx context.Context, msg *nats.Msg) error {

        Logger.Info("Received new token generation request")
        verdict := "success"

        defer func() {
                Logger.Info("Generation token request terminated")
                AuthRequests.Add(ctx, 1, metric.WithAttributes(attribute.String("verdict", verdict)))
        }()

        var dto common.AuthLoginRequest
        err := json.Unmarshal(msg.Data, &dto)
        if err != nil {
                verdict = "bad request"
                Logger.Debug("Bad request", zap.Error(err))
                err = broker.RespondToMsg(msg, common.AuthLoginResponse{Token: ""})
                if err != nil {
                        Logger.Error("Cannot send response", zap.Error(err))
                        return err
                }
                return nil
        }

        err = ar.checkGetTokenRequest(&dto)

        if err != nil {
                Logger.Debug("Bad username provided", zap.Error(err))
                err = broker.RespondToMsg(msg, common.AuthLoginResponse{Token: ""})
                if err != nil {
                        Logger.Error("Cannot send response", zap.Error(err))
                }
                verdict = "bad request"
                return err
        }

        tokenResponse := ar.tokenUseCase.GetToken(servicecmd.NewGetTokenCmd(dto.Username))

        if tokenResponse.GetError() != nil {
                Logger.Debug("Cannot generate token", zap.Error(err))
                err = broker.RespondToMsg(msg, common.AuthLoginResponse{Token: ""})
                if err != nil {
                        Logger.Error("Cannot send response", zap.Error(err))
                }
                verdict = "cannot generate token"
                return err
        }

        err = broker.RespondToMsg(msg, common.AuthLoginResponse{Token: tokenResponse.GetToken()})
        if err != nil {
                Logger.Error("Cannot send response", zap.Error(err))
                verdict = "token generated"
                return err
        }
        return nil
}

1	package controller
2
3	import (
4	"context"
5	"encoding/json"
6	"sync"
7
8	"github.com/alimitedgroup/MVP/common"
9	"github.com/alimitedgroup/MVP/common/lib/broker"
10	"github.com/alimitedgroup/MVP/common/lib/observability"
11	commonauth "github.com/alimitedgroup/MVP/srv/authenticator/authCommon"
12	servicecmd "github.com/alimitedgroup/MVP/srv/authenticator/service/cmd"
13	serviceportin "github.com/alimitedgroup/MVP/srv/authenticator/service/portIn"
14	"github.com/nats-io/nats.go"
15	"go.opentelemetry.io/otel/attribute"
16	"go.opentelemetry.io/otel/metric"
17	"go.uber.org/fx"
18	"go.uber.org/zap"
19	)
20
21	var (
22	AuthRequests metric.Int64Counter
23	Logger *zap.Logger
24	metricMap sync.Map
25	)
26
27	type MetricParams struct {
28	fx.In
29	Logger *zap.Logger
30	Meter metric.Meter
31	}
32
33	type authController struct {
34	tokenUseCase serviceportin.IGetTokenUseCase
35	}
36
37	func NewAuthController(tokenUseCase serviceportin.IGetTokenUseCase, mp MetricParams) *authController {	5✔
38	observability.CounterSetup(&mp.Meter, mp.Logger, &AuthRequests, &metricMap, "num_token_requests")	5✔
39	Logger = mp.Logger	5✔
40	return &authController{tokenUseCase: tokenUseCase}	5✔
41	}	5✔
42
43	func (ar authController) checkGetTokenRequest(dto common.AuthLoginRequest) error {	3✔
44	if dto.Username == "" {	4✔
45	return commonauth.ErrUserNotLegit	1✔
46	}	1✔
47	return nil	2✔
48	}
49
50	func (ar authController) NewTokenRequest(ctx context.Context, msg nats.Msg) error {	4✔
51		4✔
52	Logger.Info("Received new token generation request")	4✔
53	verdict := "success"	4✔
54		4✔
55	defer func() {	8✔
56	Logger.Info("Generation token request terminated")	4✔
57	AuthRequests.Add(ctx, 1, metric.WithAttributes(attribute.String("verdict", verdict)))	4✔
58	}()	4✔
59
60	var dto common.AuthLoginRequest	4✔
61	err := json.Unmarshal(msg.Data, &dto)	4✔
62	if err != nil {	5✔
63	verdict = "bad request"	1✔
64	Logger.Debug("Bad request", zap.Error(err))	1✔
65	err = broker.RespondToMsg(msg, common.AuthLoginResponse{Token: ""})	1✔
66	if err != nil {	1✔
NEW 67	Logger.Error("Cannot send response", zap.Error(err))	×
68	return err	×
69	}	×
70	return nil	1✔
71	}
72
73	err = ar.checkGetTokenRequest(&dto)	3✔
74		3✔
75	if err != nil {	4✔
76	Logger.Debug("Bad username provided", zap.Error(err))	1✔
77	err = broker.RespondToMsg(msg, common.AuthLoginResponse{Token: ""})	1✔
78	if err != nil {	1✔
NEW 79	Logger.Error("Cannot send response", zap.Error(err))	×
80	}	×
81	verdict = "bad request"	1✔
82	return err	1✔
83	}
84
85	tokenResponse := ar.tokenUseCase.GetToken(servicecmd.NewGetTokenCmd(dto.Username))	2✔
86		2✔
87	if tokenResponse.GetError() != nil {	3✔
88	Logger.Debug("Cannot generate token", zap.Error(err))	1✔
89	err = broker.RespondToMsg(msg, common.AuthLoginResponse{Token: ""})	1✔
90	if err != nil {	1✔
NEW 91	Logger.Error("Cannot send response", zap.Error(err))	×
92	}	×
93	verdict = "cannot generate token"	1✔
94	return err	1✔
95	}
96
97	err = broker.RespondToMsg(msg, common.AuthLoginResponse{Token: tokenResponse.GetToken()})	1✔
98	if err != nil {	1✔
NEW 99	Logger.Error("Cannot send response", zap.Error(err))	×
NEW 100	verdict = "token generated"	×
101	return err	×
102	}	×
103	return nil	1✔
104	}

alimitedgroup / MVP / 14147634314

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