Coverage Report

Generated on Wed, 19 Feb 2025 07:02:15 UTC with gocov-html

Report Overview

`github.com/xgmsx/go-tiny-url/cmd/app`	`100.0%`	`19/19`
`github.com/xgmsx/go-tiny-url/cmd/app/mocks`	`100.0%`	`21/21`
`github.com/xgmsx/go-tiny-url/docs`	`100.0%`	`1/1`
`github.com/xgmsx/go-tiny-url/internal/app`	`2.2%`	`1/45`
`github.com/xgmsx/go-tiny-url/internal/config`	`33.3%`	`1/3`
`github.com/xgmsx/go-tiny-url/internal/domain/adapter/kafka`	`0.0%`	`0/7`
`github.com/xgmsx/go-tiny-url/internal/domain/adapter/postgres`	`0.0%`	`0/29`
`github.com/xgmsx/go-tiny-url/internal/domain/adapter/redis`	`0.0%`	`0/22`
`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc`	`93.9%`	`31/33`
`github.com/xgmsx/go-tiny-url/internal/domain/controller/http`	`100.0%`	`54/54`
`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka`	`81.8%`	`18/22`
`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks`	`100.0%`	`21/21`
`github.com/xgmsx/go-tiny-url/internal/domain/dto`	`89.5%`	`17/19`
`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create`	`86.7%`	`13/15`
`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks`	`100.0%`	`30/30`
`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch`	`93.8%`	`15/16`
`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks`	`100.0%`	`28/28`
`github.com/xgmsx/go-tiny-url/pkg/grpc`	`92.3%`	`12/13`
`github.com/xgmsx/go-tiny-url/pkg/http`	`0.0%`	`0/38`
`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics`	`100.0%`	`56/56`
`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces`	`100.0%`	`62/62`
`github.com/xgmsx/go-tiny-url/pkg/kafka/reader`	`0.0%`	`0/6`
`github.com/xgmsx/go-tiny-url/pkg/kafka/writer`	`0.0%`	`0/6`
`github.com/xgmsx/go-tiny-url/pkg/logger`	`77.8%`	`7/9`
`github.com/xgmsx/go-tiny-url/pkg/observability/otel`	`34.5%`	`10/29`
`github.com/xgmsx/go-tiny-url/pkg/observability/otel/tracer`	`50.0%`	`3/6`
`github.com/xgmsx/go-tiny-url/pkg/observability/sentry`	`50.0%`	`5/10`
`github.com/xgmsx/go-tiny-url/pkg/postgres`	`0.0%`	`0/10`
`github.com/xgmsx/go-tiny-url/pkg/redis`	`0.0%`	`0/6`
`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1`	`12.1%`	`15/124`

This coverage report has been generated with the following command:

gocov test github.com/xgmsx/go-tiny-url/cmd/app github.com/xgmsx/go-tiny-url/cmd/app/mocks github.com/xgmsx/go-tiny-url/docs github.com/xgmsx/go-tiny-url/internal/app github.com/xgmsx/go-tiny-url/internal/config github.com/xgmsx/go-tiny-url/internal/domain/adapter/kafka github.com/xgmsx/go-tiny-url/internal/domain/adapter/postgres github.com/xgmsx/go-tiny-url/internal/domain/adapter/redis github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc github.com/xgmsx/go-tiny-url/internal/domain/controller/http github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks github.com/xgmsx/go-tiny-url/internal/domain/dto github.com/xgmsx/go-tiny-url/internal/domain/usecase/create github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks github.com/xgmsx/go-tiny-url/pkg/grpc github.com/xgmsx/go-tiny-url/pkg/http github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces github.com/xgmsx/go-tiny-url/pkg/kafka/reader github.com/xgmsx/go-tiny-url/pkg/kafka/writer github.com/xgmsx/go-tiny-url/pkg/logger github.com/xgmsx/go-tiny-url/pkg/observability/otel github.com/xgmsx/go-tiny-url/pkg/observability/otel/tracer github.com/xgmsx/go-tiny-url/pkg/observability/sentry github.com/xgmsx/go-tiny-url/pkg/postgres github.com/xgmsx/go-tiny-url/pkg/redis github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1 | gocov-html

Package Overview: github.com/xgmsx/go-tiny-url/cmd/app 100.0%

Please select a function to see what's left for testing.

`run(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/main.go`	`100.0%`	`15/15`
`main(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/main.go`	`100.0%`	`4/4`

func run

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/main.go:

func run(ctx context.Context, cl configLoader, ar appRunner) error {
        c, err := cl.Load(ctx)
        if err != nil {
                log.Error().Err(err).Msg("config.New")
                return err
        }

        logger.Init(c.Logger, c.App.Name, c.App.Version)
        log.Info().Msg("App starting...")
        defer log.Info().Msg("App stopped")

        sentry.Init(c.Sentry, c.App.Name, c.App.Version, c.App.Env)
        defer sentry.Close()

        otel.Init(ctx, c.Otel, c.App.Name, c.App.Version)
        defer otel.Close()

        err = ar.Run(ctx, c)
        if err != nil {
                log.Error().Err(err).Msg("app.Run")
        }
        return err
}

func main

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/main.go:

func main() {
        ctx, cancel := context.WithCancel(context.Background())
        defer cancel()

        if err := run(ctx, cl, ar); err != nil {
                panic(err)
        }
}

Package Overview: github.com/xgmsx/go-tiny-url/cmd/app/mocks 100.0%

Please select a function to see what's left for testing.

`MockconfigLoader.Load(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/mocks/contract.go`	`100.0%`	`5/5`
`MockappRunner.Run(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/mocks/contract.go`	`100.0%`	`4/4`
`NewMockappRunner(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/mocks/contract.go`	`100.0%`	`3/3`
`NewMockconfigLoader(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/mocks/contract.go`	`100.0%`	`3/3`
`MockappRunnerMockRecorder.Run(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/mocks/contract.go`	`100.0%`	`2/2`
`MockconfigLoaderMockRecorder.Load(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/mocks/contract.go`	`100.0%`	`2/2`
`MockappRunner.EXPECT(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/mocks/contract.go`	`100.0%`	`1/1`
`MockconfigLoader.EXPECT(...)`	`github.com/xgmsx/go-tiny-url/cmd/app/mocks/contract.go`	`100.0%`	`1/1`

func MockconfigLoader.Load

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/mocks/contract.go:

func (m *MockconfigLoader) Load(ctx context.Context) (*config.Config, error) {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "Load", ctx)
        ret0, _ := ret[0].(*config.Config)
        ret1, _ := ret[1].(error)
        return ret0, ret1
}

func MockappRunner.Run

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/mocks/contract.go:

func (m *MockappRunner) Run(ctx context.Context, c *config.Config) error {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "Run", ctx, c)
        ret0, _ := ret[0].(error)
        return ret0
}

func NewMockappRunner

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/mocks/contract.go:

func NewMockappRunner(ctrl *gomock.Controller) *MockappRunner {
        mock := &MockappRunner{ctrl: ctrl}
        mock.recorder = &MockappRunnerMockRecorder{mock}
        return mock
}

func NewMockconfigLoader

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/mocks/contract.go:

func NewMockconfigLoader(ctrl *gomock.Controller) *MockconfigLoader {
        mock := &MockconfigLoader{ctrl: ctrl}
        mock.recorder = &MockconfigLoaderMockRecorder{mock}
        return mock
}

func MockappRunnerMockRecorder.Run

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/mocks/contract.go:

54	`func (mr MockappRunnerMockRecorder) Run(ctx, c any) gomock.Call {`
55	`mr.mock.ctrl.T.Helper()`
56	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockappRunner)(nil).Run), ctx, c)`
57	`}`

func MockconfigLoaderMockRecorder.Load

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/mocks/contract.go:

93	`func (mr MockconfigLoaderMockRecorder) Load(ctx any) gomock.Call {`
94	`mr.mock.ctrl.T.Helper()`
95	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Load", reflect.TypeOf((*MockconfigLoader)(nil).Load), ctx)`
96	`}`

func MockappRunner.EXPECT

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/mocks/contract.go:

41	`func (m MockappRunner) EXPECT() MockappRunnerMockRecorder {`
42	`return m.recorder`
43	`}`

func MockconfigLoader.EXPECT

Back

In /home/runner/work/go-tiny-url/go-tiny-url/cmd/app/mocks/contract.go:

79	`func (m MockconfigLoader) EXPECT() MockconfigLoaderMockRecorder {`
80	`return m.recorder`
81	`}`

Package Overview: github.com/xgmsx/go-tiny-url/docs 100.0%

Please select a function to see what's left for testing.

init(...) github.com/xgmsx/go-tiny-url/docs/docs.go 100.0% 1/1

func init

Back

In /home/runner/work/go-tiny-url/go-tiny-url/docs/docs.go:

233	`func init() {`
234	`swag.Register(SwaggerInfo.InstanceName(), SwaggerInfo)`
235	`}`

Package Overview: github.com/xgmsx/go-tiny-url/internal/app 2.2%

Please select a function to see what's left for testing.

`New(...)`	`github.com/xgmsx/go-tiny-url/internal/app/app.go`	`100.0%`	`1/1`
`App.Run(...)`	`github.com/xgmsx/go-tiny-url/internal/app/app.go`	`0.0%`	`0/32`
`App.waiting(...)`	`github.com/xgmsx/go-tiny-url/internal/app/app.go`	`0.0%`	`0/9`
`@74:5(...)`	`github.com/xgmsx/go-tiny-url/internal/app/app.go`	`0.0%`	`0/1`
`@78:5(...)`	`github.com/xgmsx/go-tiny-url/internal/app/app.go`	`0.0%`	`0/1`
`@82:5(...)`	`github.com/xgmsx/go-tiny-url/internal/app/app.go`	`0.0%`	`0/1`

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/app/app.go:

30	`func New() App {`
31	`return App{}`
32	`}`

func App.Run

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/app/app.go:

func (a App) Run(ctx context.Context, c *config.Config) error {
        // init dependencies
        postgres, err := postgresClient.New(ctx, &c.Postgres)
        if err != nil {
                return fmt.Errorf("postgres.New: %w", err)
        }
        defer postgres.Close()

        redis, err := redisClient.New(&c.Redis)
        if err != nil {
                return fmt.Errorf("redis.New: %w", err)
        }
        defer redis.Close()

        KafkaWriter, err := kafkaWriter.New(&c.KafkaWriter)
        if err != nil {
                return fmt.Errorf("kafkaWriter.New: %w", err)
        }
        defer KafkaWriter.Close()

        KafkaReader, err := kafkaReader.New(&c.KafkaReader)
        if err != nil {
                return fmt.Errorf("kafkaReader.New: %w", err)
        }
        defer KafkaReader.Close()

        // init adapter
        database := adapterPostgres.New(postgres.Pool)
        cache := adapterRedis.New(redis.Client)
        publisher := adapterKafka.New(KafkaWriter.Writer)

        // init usecase
        ucCreateLink := usecaseCreate.New(database, cache, publisher)
        ucFetchLink := usecaseFetch.New(database, cache)

        // init controller
        errCh := make(chan error)
        defer close(errCh)

        httpServer := http.New(c.HTTP, nil, controllerHTTP.New("/api/shortener", ucCreateLink, ucFetchLink))
        go func() { errCh <- httpServer.Serve(c.HTTP.Port) }()
        defer httpServer.Close()

        grpcServer := grpc.New(controllerGRPC.New(ucCreateLink, ucFetchLink))
        go func() { errCh <- grpcServer.Serve(ctx, c.GRPC.Port) }()
        defer grpcServer.Close()

        kafkaConsumer := controllerKafka.New(KafkaReader, ucCreateLink)
        go func() { errCh <- kafkaConsumer.Consume(ctx) }()

        return a.waiting(errCh)
}

func App.waiting

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/app/app.go:

func (a App) waiting(errCh <-chan error) error {
        log.Info().Msg("App started")
        defer log.Info().Msg("App stopping...")

        ctxTerm, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)
        defer stop()

        select {
        case <-ctxTerm.Done():
                log.Info().Msg("App got termination signal")
                return nil
        case err := <-errCh:
                log.Info().Err(err).Msg("App got error notify")
                return err
        }
}

func @74:5

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/app/app.go:

74	`func() { errCh <- httpServer.Serve(c.HTTP.Port) }`

func @78:5

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/app/app.go:

78	`func() { errCh <- grpcServer.Serve(ctx, c.GRPC.Port) }`

func @82:5

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/app/app.go:

82	`func() { errCh <- kafkaConsumer.Consume(ctx) }`

Package Overview: github.com/xgmsx/go-tiny-url/internal/config 33.3%

Please select a function to see what's left for testing.

`New(...)`	`github.com/xgmsx/go-tiny-url/internal/config/config.go`	`100.0%`	`1/1`
`Config.Load(...)`	`github.com/xgmsx/go-tiny-url/internal/config/config.go`	`0.0%`	`0/2`

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/config/config.go:

41	`func New() *Config {`
42	`return &Config{}`
43	`}`

func Config.Load

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/config/config.go:

45	`func (c Config) Load(ctx context.Context) (Config, error) {`
46	`err := envconfig.Process(ctx, c)`
47	`return c, err`
48	`}`

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/adapter/kafka 0.0%

Please select a function to see what's left for testing.

`Producer.SendLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/adapter/kafka/producer.go`	`0.0%`	`0/6`
`New(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/adapter/kafka/producer.go`	`0.0%`	`0/1`

func Producer.SendLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/adapter/kafka/producer.go:

func (p *Producer) SendLink(ctx context.Context, l entity.Link) error {
        ctx, span := tracer.Start(ctx, "kafka SendLink")
        defer span.End()

        err := p.writer.WriteMessages(ctx, kafka.Message{
                Key:   []byte(l.Alias),
                Value: []byte(l.URL),
        })
        if err != nil {
                return fmt.Errorf("p.writer.WriteMessages: %w", err)
        }

        return nil
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/adapter/kafka/producer.go:

17	`func New(writer kafka.Writer) Producer {`
18	`return &Producer{writer: writer}`
19	`}`

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/adapter/postgres 0.0%

Please select a function to see what's left for testing.

`Postgres.FindLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/adapter/postgres/postgres.go`	`0.0%`	`0/18`
`Postgres.CreateLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/adapter/postgres/postgres.go`	`0.0%`	`0/10`
`New(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/adapter/postgres/postgres.go`	`0.0%`	`0/1`

func Postgres.FindLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/adapter/postgres/postgres.go:

func (p *Postgres) FindLink(ctx context.Context, alias, url string) (*entity.Link, error) {
        ctx, span := tracer.Start(ctx, "postgres FindLink")
        defer span.End()

        var link entity.Link

        dataset := goqu.
                Select("id", "url", "alias", "expired_at").
                From("links")

        switch {
        case alias != "" && url != "":
                dataset = dataset.Where(goqu.C("alias").Eq(alias), goqu.C("url").Eq(url))
        case alias != "":
                dataset = dataset.Where(goqu.C("alias").Eq(alias))
        case url != "":
                dataset = dataset.Where(goqu.C("url").Eq(url))
        default:
                return nil, fmt.Errorf("query validation")
        }

        sql, _, err := dataset.ToSQL()
        if err != nil {
                return nil, fmt.Errorf("dataset.ToSQL: %w", err)
        }

        row := p.pool.QueryRow(ctx, sql)
        if err := row.Scan(&link.ID, &link.URL, &link.Alias, &link.ExpiredAt); err != nil {
                if errors.Is(err, pgx.ErrNoRows) {
                        return nil, entity.ErrNotFound
                }
                return nil, fmt.Errorf("row.Scan: %w", err)
        }

        return &link, nil
}

func Postgres.CreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/adapter/postgres/postgres.go:

func (p *Postgres) CreateLink(ctx context.Context, link entity.Link) error {
        ctx, span := tracer.Start(ctx, "postgres CreateLink")
        defer span.End()

        dataset := goqu.Insert("links").Rows(goqu.Record{
                "id":         link.ID,
                "url":        link.URL,
                "alias":      link.Alias,
                "updated_at": time.Now(),
                "expired_at": link.ExpiredAt,
        })

        sql, _, err := dataset.ToSQL()
        if err != nil {
                return fmt.Errorf("dataset.ToSQL: %w", err)
        }

        _, err = p.pool.Exec(ctx, sql)
        if err != nil {
                return fmt.Errorf("r.pool.Exec: %w", err)
        }

        return nil
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/adapter/postgres/postgres.go:

func New(p *pgxpool.Pool) *Postgres {
        return &Postgres{
                pool: p,
        }
}

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/adapter/redis 0.0%

Please select a function to see what's left for testing.

`Redis.GetLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/adapter/redis/redis.go`	`0.0%`	`0/12`
`Redis.PutLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/adapter/redis/redis.go`	`0.0%`	`0/9`
`New(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/adapter/redis/redis.go`	`0.0%`	`0/1`

func Redis.GetLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/adapter/redis/redis.go:

func (r *Redis) GetLink(ctx context.Context, alias string) (*entity.Link, error) {
        ctx, span := tracer.Start(ctx, "redis GetLink")
        defer span.End()

        var link entity.Link

        data, err := r.client.Get(ctx, alias).Bytes()
        if err != nil {
                if errors.Is(err, redis.Nil) {
                        return nil, entity.ErrNotFound
                }

                return nil, fmt.Errorf("r.client.Get: %w", err)
        }

        err = json.Unmarshal(data, &link)
        if err != nil {
                return nil, fmt.Errorf("json.Unmarshal: %w", err)
        }

        return &link, nil
}

func Redis.PutLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/adapter/redis/redis.go:

func (r *Redis) PutLink(ctx context.Context, link entity.Link) error {
        ctx, span := tracer.Start(ctx, "redis PutLink")
        defer span.End()

        data, err := json.Marshal(link)
        if err != nil {
                return fmt.Errorf("json.Marshal: %w", err)
        }

        err = r.client.Set(ctx, link.Alias, data, ttl).Err()
        if err != nil {
                return fmt.Errorf("r.client.Set: %w", err)
        }

        return nil
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/adapter/redis/redis.go:

22	`func New(client redis.Client) Redis {`
23	`return &Redis{client: client}`
24	`}`

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc 93.9%

Please select a function to see what's left for testing.

`HandlerFetchLink.FetchLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc/handlers.go`	`100.0%`	`14/14`
`HandlerCreateLink.CreateLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc/handlers.go`	`100.0%`	`13/13`
`New(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc/controller.go`	`100.0%`	`1/1`
`Controller.Register(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc/controller.go`	`100.0%`	`1/1`
`NewHandlerCreateLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc/handlers.go`	`100.0%`	`1/1`
`NewHandlerFetchLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc/handlers.go`	`100.0%`	`1/1`
`Controller.CreateLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc/controller.go`	`0.0%`	`0/1`
`Controller.FetchLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/grpc/controller.go`	`0.0%`	`0/1`

func HandlerFetchLink.FetchLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/grpc/handlers.go:

func (h *HandlerFetchLink) FetchLink(ctx context.Context, req *pb.FetchLinkRequest) (*pb.FetchLinkResponse, error) {
        ctx, span := tracer.Start(ctx, "grpc/v1 FetchLink")
        defer span.End()

        input := dto.FetchLinkInput{Alias: req.GetAlias()}
        if err := input.Validate(); err != nil {
                log.Error().Err(err).Msg("uc.FetchLink: validate error")
                return nil, fmt.Errorf("validation error")
        }

        output, err := h.uc.Fetch(ctx, input)
        if err != nil {
                switch {
                case errors.Is(err, entity.ErrNotFound):
                        log.Error().Err(err).Msg("uc.FetchLink: not found")
                        return nil, fmt.Errorf("not found")
                default:
                        log.Error().Err(err).Msg("uc.FetchLink: internal error")
                        return nil, fmt.Errorf("internal error")
                }
        }

        return &pb.FetchLinkResponse{
                Url:       output.URL,
                Alias:     output.Alias,
                ExpiredAt: timestamppb.New(output.ExpiredAt),
        }, nil
}

func HandlerCreateLink.CreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/grpc/handlers.go:

func (h *HandlerCreateLink) CreateLink(ctx context.Context, req *pb.CreateLinkRequest) (*pb.CreateLinkResponse, error) {
        ctx, span := tracer.Start(ctx, "grpc/v1 CreateLink")
        defer span.End()

        input := dto.CreateLinkInput{URL: req.GetUrl()}
        if err := input.Validate(); err != nil {
                log.Error().Err(err).Msg("uc.CreateLink: validate error")
                return nil, fmt.Errorf("validation error")
        }

        output, err := h.uc.Create(ctx, input)
        if err != nil {
                switch {
                case errors.Is(err, entity.ErrAlreadyExist):
                        return &pb.CreateLinkResponse{
                                Url:       input.URL,
                                Alias:     output.Alias,
                                ExpiredAt: timestamppb.New(output.ExpiredAt),
                        }, nil
                default:
                        log.Error().Err(err).Msg("uc.CreateLink: internal error")
                        return nil, fmt.Errorf("internal error")
                }
        }

        return &pb.CreateLinkResponse{
                Url:       input.URL,
                Alias:     output.Alias,
                ExpiredAt: timestamppb.New(output.ExpiredAt),
        }, nil
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/grpc/controller.go:

func New(ucCreate create.Usecase, ucFetch fetch.Usecase) *Controller {
        return &Controller{
                createHandler: NewHandlerCreateLink(ucCreate),
                fetchHandler:  NewHandlerFetchLink(ucFetch),
        }
}

func Controller.Register

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/grpc/controller.go:

34	`func (c Controller) Register(server grpc.Server) {`
35	`pb.RegisterShortenerServer(server, c)`
36	`}`

func NewHandlerCreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/grpc/handlers.go:

24	`func NewHandlerCreateLink(uc create.Usecase) *HandlerCreateLink {`
25	`return &HandlerCreateLink{uc: uc}`
26	`}`

func NewHandlerFetchLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/grpc/handlers.go:

64	`func NewHandlerFetchLink(uc fetch.Usecase) *HandlerFetchLink {`
65	`return &HandlerFetchLink{uc: uc}`
66	`}`

func Controller.CreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/grpc/controller.go:

26	`func (c Controller) CreateLink(ctx context.Context, req pb.CreateLinkRequest) (*pb.CreateLinkResponse, error) {`
27	`return c.createHandler.CreateLink(ctx, req)`
28	`}`

func Controller.FetchLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/grpc/controller.go:

30	`func (c Controller) FetchLink(ctx context.Context, req pb.FetchLinkRequest) (*pb.FetchLinkResponse, error) {`
31	`return c.fetchHandler.FetchLink(ctx, req)`
32	`}`

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/controller/http 100.0%

Please select a function to see what's left for testing.

`HandlerCreateLink.Handler(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/http/handlers.go`	`100.0%`	`16/16`
`HandlerFetchLink.Handler(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/http/handlers.go`	`100.0%`	`15/15`
`HandlerRedirect.Handler(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/http/handlers.go`	`100.0%`	`15/15`
`Controller.Register(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/http/controller.go`	`100.0%`	`4/4`
`New(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/http/controller.go`	`100.0%`	`1/1`
`NewHandlerCreateLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/http/handlers.go`	`100.0%`	`1/1`
`NewHandlerFetchLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/http/handlers.go`	`100.0%`	`1/1`
`NewHandlerRedirect(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/http/handlers.go`	`100.0%`	`1/1`

func HandlerCreateLink.Handler

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/http/handlers.go:

func (h *HandlerCreateLink) Handler(c *fiber.Ctx) error {
        ctx, span := tracer.Start(c.Context(), "http/v1 CreateLink")
        defer span.End()

        var input dto.CreateLinkInput
        if err := c.BodyParser(&input); err != nil {
                log.Error().Err(err).Msg("c.BodyParser")
                return fiber.NewError(fiber.StatusBadRequest, "invalid json")
        }

        if err := input.Validate(); err != nil {
                log.Error().Err(err).Msg("uc.CreateLink: validation error")
                return fiber.NewError(fiber.StatusBadRequest, "validation error")
        }

        output, err := h.uc.Create(ctx, input)
        if err != nil {
                switch {
                case errors.Is(err, entity.ErrAlreadyExist):
                        return c.Status(fiber.StatusFound).JSON(output)
                default:
                        log.Error().Err(err).Msg("uc.CreateLink: internal error")
                        return fiber.NewError(fiber.StatusInternalServerError, "internal error")
                }
        }

        return c.Status(fiber.StatusCreated).JSON(output)
}

func HandlerFetchLink.Handler

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/http/handlers.go:

func (h *HandlerFetchLink) Handler(c *fiber.Ctx) error {
        ctx, span := tracer.Start(c.Context(), "http/v1 FetchLink")
        defer span.End()

        alias := c.Params("alias")

        input := dto.FetchLinkInput{Alias: alias}
        if err := input.Validate(); err != nil {
                log.Error().Msg("uc.FetchLink: alias is required")
                return fiber.NewError(fiber.StatusBadRequest, "validation error")
        }

        output, err := h.uc.Fetch(ctx, input)
        if err != nil {
                switch {
                case errors.Is(err, entity.ErrNotFound):
                        log.Error().Err(err).Msg("uc.FetchLink: not found")
                        return fiber.NewError(fiber.StatusNotFound, "not found")
                default:
                        log.Error().Err(err).Msg("uc.FetchLink: internal error")
                        return fiber.NewError(fiber.StatusInternalServerError, "internal error")
                }
        }

        return c.Status(fiber.StatusOK).JSON(output)
}

func HandlerRedirect.Handler

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/http/handlers.go:

func (h *HandlerRedirect) Handler(c *fiber.Ctx) error {
        ctx, span := tracer.Start(c.Context(), "http/v1 Redirect")
        defer span.End()

        alias := c.Params("alias")

        input := dto.FetchLinkInput{Alias: alias}
        if err := input.Validate(); err != nil {
                log.Error().Msg("uc.FetchLink: alias is required")
                return fiber.NewError(fiber.StatusBadRequest, "validation error")
        }

        output, err := h.uc.Fetch(ctx, input)
        if err != nil {
                switch {
                case errors.Is(err, entity.ErrNotFound):
                        log.Error().Err(err).Msg("uc.FetchLink: not found")
                        return fiber.NewError(fiber.StatusNotFound, "not found")
                default:
                        log.Error().Err(err).Msg("uc.FetchLink: internal error")
                        return fiber.NewError(fiber.StatusInternalServerError, "internal error")
                }
        }

        return c.Redirect(output.URL, fiber.StatusFound)
}

func Controller.Register

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/http/controller.go:

func (c *Controller) Register(app *fiber.App) {
        r := app.Group(c.prefix)
        r.Post("/link", NewHandlerCreateLink(c.ucCreate).Handler)
        r.Get("/link/:alias", NewHandlerFetchLink(c.ucFetch).Handler)
        r.Get("/link/:alias/redirect", NewHandlerRedirect(c.ucFetch).Handler)
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/http/controller.go:

16	`func New(prefix string, ucCreate create.Usecase, ucFetch fetch.Usecase) *Controller {`
17	`return &Controller{prefix, ucCreate, ucFetch}`
18	`}`

func NewHandlerCreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/http/handlers.go:

21	`func NewHandlerCreateLink(uc create.Usecase) *HandlerCreateLink {`
22	`return &HandlerCreateLink{uc: uc}`
23	`}`

func NewHandlerFetchLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/http/handlers.go:

71	`func NewHandlerFetchLink(uc fetch.Usecase) *HandlerFetchLink {`
72	`return &HandlerFetchLink{uc: uc}`
73	`}`

func NewHandlerRedirect

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/http/handlers.go:

118	`func NewHandlerRedirect(uc fetch.Usecase) *HandlerRedirect {`
119	`return &HandlerRedirect{uc: uc}`
120	`}`

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka 81.8%

Please select a function to see what's left for testing.

`New(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/controller.go`	`100.0%`	`1/1`
`Consumer.Consume(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/controller.go`	`81.0%`	`17/21`

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/kafka/controller.go:

18	`func New(k kafkaReader, uc create.Usecase) *Consumer {`
19	`return &Consumer{kafka: k, uc: uc}`
20	`}`

func Consumer.Consume

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/kafka/controller.go:

func (c *Consumer) Consume(ctx context.Context) error {
        log.Info().Msg("Kafka consumer started")
        for {
                select {
                case <-ctx.Done():
                        return nil
                default:
                        m, err := c.kafka.FetchMessage(ctx)
                        if err != nil {
                                log.Error().Err(err).Msg("c.kafka.FetchMessage")
                                continue
                        }

                        var input dto.CreateLinkInput
                        err = json.Unmarshal(m.Value, &input)
                        if err != nil {
                                log.Error().Err(err).Msg("json.Unmarshal")
                                continue
                        }

                        output, err := c.uc.Create(ctx, input)
                        if err != nil {
                                log.Error().Err(err).Msg("uc.CreateLink")
                                continue
                        }
                        log.Info().Msg("Link created: " + output.Str())

                        if err = c.kafka.CommitMessages(ctx, m); err != nil {
                                log.Error().Err(err).Msg("c.kafka.CommitMessages")
                                continue
                        }
                }
        }
}

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks 100.0%

Please select a function to see what's left for testing.

`MockkafkaReader.CommitMessages(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go`	`100.0%`	`7/7`
`MockkafkaReader.FetchMessage(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go`	`100.0%`	`5/5`
`NewMockkafkaReader(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go`	`100.0%`	`3/3`
`MockkafkaReaderMockRecorder.CommitMessages(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go`	`100.0%`	`3/3`
`MockkafkaReaderMockRecorder.FetchMessage(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go`	`100.0%`	`2/2`
`MockkafkaReader.EXPECT(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go`	`100.0%`	`1/1`

func MockkafkaReader.CommitMessages

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go:

func (m *MockkafkaReader) CommitMessages(ctx context.Context, msgs ...kafka.Message) error {
        m.ctrl.T.Helper()
        varargs := []any{ctx}
        for _, a := range msgs {
                varargs = append(varargs, a)
        }
        ret := m.ctrl.Call(m, "CommitMessages", varargs...)
        ret0, _ := ret[0].(error)
        return ret0
}

func MockkafkaReader.FetchMessage

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go:

func (m *MockkafkaReader) FetchMessage(ctx context.Context) (kafka.Message, error) {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "FetchMessage", ctx)
        ret0, _ := ret[0].(kafka.Message)
        ret1, _ := ret[1].(error)
        return ret0, ret1
}

func NewMockkafkaReader

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go:

func NewMockkafkaReader(ctrl *gomock.Controller) *MockkafkaReader {
        mock := &MockkafkaReader{ctrl: ctrl}
        mock.recorder = &MockkafkaReaderMockRecorder{mock}
        return mock
}

func MockkafkaReaderMockRecorder.CommitMessages

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go:

func (mr *MockkafkaReaderMockRecorder) CommitMessages(ctx any, msgs ...any) *gomock.Call {
        mr.mock.ctrl.T.Helper()
        varargs := append([]any{ctx}, msgs...)
        return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitMessages", reflect.TypeOf((*MockkafkaReader)(nil).CommitMessages), varargs...)
}

func MockkafkaReaderMockRecorder.FetchMessage

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go:

73	`func (mr MockkafkaReaderMockRecorder) FetchMessage(ctx any) gomock.Call {`
74	`mr.mock.ctrl.T.Helper()`
75	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMessage", reflect.TypeOf((*MockkafkaReader)(nil).FetchMessage), ctx)`
76	`}`

func MockkafkaReader.EXPECT

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/controller/kafka/mocks/contract.go:

40	`func (m MockkafkaReader) EXPECT() MockkafkaReaderMockRecorder {`
41	`return m.recorder`
42	`}`

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/dto 89.5%

Please select a function to see what's left for testing.

`CreateLinkOutput.Load(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/dto/create.go`	`100.0%`	`4/4`
`FetchLinkOutput.Load(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/dto/fetch.go`	`100.0%`	`4/4`
`CreateLinkInput.Validate(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/dto/create.go`	`100.0%`	`3/3`
`FetchLinkInput.Validate(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/dto/fetch.go`	`100.0%`	`3/3`
`CreateLinkOutput.Str(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/dto/create.go`	`60.0%`	`3/5`

func CreateLinkOutput.Load

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/dto/create.go:

func (o CreateLinkOutput) Load(l entity.Link) CreateLinkOutput {
        o.URL = l.URL
        o.Alias = l.Alias
        o.ExpiredAt = l.ExpiredAt

        return o
}

func FetchLinkOutput.Load

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/dto/fetch.go:

func (o FetchLinkOutput) Load(l *entity.Link) FetchLinkOutput {
        o.URL = l.URL
        o.Alias = l.Alias
        o.ExpiredAt = l.ExpiredAt

        return o
}

func CreateLinkInput.Validate

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/dto/create.go:

func (i *CreateLinkInput) Validate() error {
        if i.URL == "" {
                return entity.ErrInputValidation
        }

        return nil
}

func FetchLinkInput.Validate

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/dto/fetch.go:

func (i FetchLinkInput) Validate() error {
        if len(i.Alias) < 2 {
                return entity.ErrInputValidation
        }
        return nil
}

func CreateLinkOutput.Str

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/dto/create.go:

func (o CreateLinkOutput) Str() string {
        b, err := json.Marshal(o)
        if err != nil {
                log.Error().Err(err).Msg("dto.Str: json.Marshal")
                return fmt.Sprintf("%v", o)
        }
        return string(b)
}

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/usecase/create 86.7%

Please select a function to see what's left for testing.

`New(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/usecase.go`	`100.0%`	`1/1`
`Usecase.Create(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/usecase.go`	`85.7%`	`12/14`

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/usecase.go:

24	`func New(d database, c cache, p publisher) Usecase {`
25	`return Usecase{database: d, cache: c, publisher: p}`
26	`}`

func Usecase.Create

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/usecase.go:

func (u *Usecase) Create(ctx context.Context, input dto.CreateLinkInput) (dto.CreateLinkOutput, error) {
        ctx, span := tracer.Start(ctx, "usecase CreateLink")
        defer span.End()

        var (
                id     = uuid.New()
                alias  = base64.RawURLEncoding.EncodeToString(id[:])
                output dto.CreateLinkOutput
        )

        link := entity.Link{
                ID:        id,
                URL:       input.URL,
                Alias:     alias,
                ExpiredAt: time.Now().Add(linkTTL),
        }

        err := u.database.CreateLink(ctx, link)
        if err != nil {
                return output, fmt.Errorf("u.database.CreateLink: %w", err)
        }

        err = u.cache.PutLink(ctx, link)
        if err != nil {
                return output, fmt.Errorf("u.cache.PutLink: %w", err)
        }

        err = u.publisher.SendLink(ctx, link)
        if err != nil {
                return output, fmt.Errorf("u.broker.SendLink: %w", err)
        }

        return output.Load(link), nil
}

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks 100.0%

Please select a function to see what's left for testing.

`Mockdatabase.CreateLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`4/4`
`Mockcache.PutLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`4/4`
`Mockpublisher.SendLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`4/4`
`NewMockdatabase(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`3/3`
`NewMockcache(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`3/3`
`NewMockpublisher(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`3/3`
`MockdatabaseMockRecorder.CreateLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`2/2`
`MockcacheMockRecorder.PutLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`2/2`
`MockpublisherMockRecorder.SendLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`2/2`
`Mockdatabase.EXPECT(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`1/1`
`Mockcache.EXPECT(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`1/1`
`Mockpublisher.EXPECT(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/create/mocks/contract.go`	`100.0%`	`1/1`

func Mockdatabase.CreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

func (m *Mockdatabase) CreateLink(arg0 context.Context, arg1 entity.Link) error {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "CreateLink", arg0, arg1)
        ret0, _ := ret[0].(error)
        return ret0
}

func Mockcache.PutLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

func (m *Mockcache) PutLink(arg0 context.Context, arg1 entity.Link) error {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "PutLink", arg0, arg1)
        ret0, _ := ret[0].(error)
        return ret0
}

func Mockpublisher.SendLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

func (m *Mockpublisher) SendLink(ctx context.Context, link entity.Link) error {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "SendLink", ctx, link)
        ret0, _ := ret[0].(error)
        return ret0
}

func NewMockdatabase

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

func NewMockdatabase(ctrl *gomock.Controller) *Mockdatabase {
        mock := &Mockdatabase{ctrl: ctrl}
        mock.recorder = &MockdatabaseMockRecorder{mock}
        return mock
}

func NewMockcache

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

func NewMockcache(ctrl *gomock.Controller) *Mockcache {
        mock := &Mockcache{ctrl: ctrl}
        mock.recorder = &MockcacheMockRecorder{mock}
        return mock
}

func NewMockpublisher

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

func NewMockpublisher(ctrl *gomock.Controller) *Mockpublisher {
        mock := &Mockpublisher{ctrl: ctrl}
        mock.recorder = &MockpublisherMockRecorder{mock}
        return mock
}

func MockdatabaseMockRecorder.CreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

54	`func (mr MockdatabaseMockRecorder) CreateLink(arg0, arg1 any) gomock.Call {`
55	`mr.mock.ctrl.T.Helper()`
56	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLink", reflect.TypeOf((*Mockdatabase)(nil).CreateLink), arg0, arg1)`
57	`}`

func MockcacheMockRecorder.PutLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

92	`func (mr MockcacheMockRecorder) PutLink(arg0, arg1 any) gomock.Call {`
93	`mr.mock.ctrl.T.Helper()`
94	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLink", reflect.TypeOf((*Mockcache)(nil).PutLink), arg0, arg1)`
95	`}`

func MockpublisherMockRecorder.SendLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

130	`func (mr MockpublisherMockRecorder) SendLink(ctx, link any) gomock.Call {`
131	`mr.mock.ctrl.T.Helper()`
132	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendLink", reflect.TypeOf((*Mockpublisher)(nil).SendLink), ctx, link)`
133	`}`

func Mockdatabase.EXPECT

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

41	`func (m Mockdatabase) EXPECT() MockdatabaseMockRecorder {`
42	`return m.recorder`
43	`}`

func Mockcache.EXPECT

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

79	`func (m Mockcache) EXPECT() MockcacheMockRecorder {`
80	`return m.recorder`
81	`}`

func Mockpublisher.EXPECT

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/create/mocks/contract.go:

117	`func (m Mockpublisher) EXPECT() MockpublisherMockRecorder {`
118	`return m.recorder`
119	`}`

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch 93.8%

Please select a function to see what's left for testing.

`New(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/usecase.go`	`100.0%`	`1/1`
`Usecase.Fetch(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/usecase.go`	`93.3%`	`14/15`

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/usecase.go:

21	`func New(d database, c cache) Usecase {`
22	`return Usecase{database: d, cache: c}`
23	`}`

func Usecase.Fetch

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/usecase.go:

func (u *Usecase) Fetch(ctx context.Context, input dto.FetchLinkInput) (dto.FetchLinkOutput, error) {
        ctx, span := tracer.Start(ctx, "usecase FetchLink")
        defer span.End()

        var output dto.FetchLinkOutput

        link, err := u.cache.GetLink(ctx, input.Alias)
        if err != nil && !errors.Is(err, entity.ErrNotFound) {
                log.Error().Err(err).Msg("u.cache.GetLink")
        }
        if link != nil {
                return output.Load(link), nil
        }

        link, err = u.database.FindLink(ctx, input.Alias, "")
        if err != nil {
                return output, fmt.Errorf("u.database.FindLink: %w", err)
        }

        err = u.cache.PutLink(ctx, *link)
        if err != nil {
                log.Error().Err(err).Msg("u.cache.PutLink")
        }

        return output.Load(link), nil
}

Package Overview: github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks 100.0%

Please select a function to see what's left for testing.

`Mockdatabase.FindLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`5/5`
`Mockcache.GetLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`5/5`
`Mockcache.PutLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`4/4`
`NewMockdatabase(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`3/3`
`NewMockcache(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`3/3`
`MockdatabaseMockRecorder.FindLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`2/2`
`MockcacheMockRecorder.GetLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`2/2`
`MockcacheMockRecorder.PutLink(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`2/2`
`Mockdatabase.EXPECT(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`1/1`
`Mockcache.EXPECT(...)`	`github.com/xgmsx/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go`	`100.0%`	`1/1`

func Mockdatabase.FindLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

func (m *Mockdatabase) FindLink(ctx context.Context, alias, url string) (*entity.Link, error) {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "FindLink", ctx, alias, url)
        ret0, _ := ret[0].(*entity.Link)
        ret1, _ := ret[1].(error)
        return ret0, ret1
}

func Mockcache.GetLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

func (m *Mockcache) GetLink(ctx context.Context, alias string) (*entity.Link, error) {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "GetLink", ctx, alias)
        ret0, _ := ret[0].(*entity.Link)
        ret1, _ := ret[1].(error)
        return ret0, ret1
}

func Mockcache.PutLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

func (m *Mockcache) PutLink(arg0 context.Context, arg1 entity.Link) error {
        m.ctrl.T.Helper()
        ret := m.ctrl.Call(m, "PutLink", arg0, arg1)
        ret0, _ := ret[0].(error)
        return ret0
}

func NewMockdatabase

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

func NewMockdatabase(ctrl *gomock.Controller) *Mockdatabase {
        mock := &Mockdatabase{ctrl: ctrl}
        mock.recorder = &MockdatabaseMockRecorder{mock}
        return mock
}

func NewMockcache

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

func NewMockcache(ctrl *gomock.Controller) *Mockcache {
        mock := &Mockcache{ctrl: ctrl}
        mock.recorder = &MockcacheMockRecorder{mock}
        return mock
}

func MockdatabaseMockRecorder.FindLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

55	`func (mr MockdatabaseMockRecorder) FindLink(ctx, alias, url any) gomock.Call {`
56	`mr.mock.ctrl.T.Helper()`
57	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindLink", reflect.TypeOf((*Mockdatabase)(nil).FindLink), ctx, alias, url)`
58	`}`

func MockcacheMockRecorder.GetLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

94	`func (mr MockcacheMockRecorder) GetLink(ctx, alias any) gomock.Call {`
95	`mr.mock.ctrl.T.Helper()`
96	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLink", reflect.TypeOf((*Mockcache)(nil).GetLink), ctx, alias)`
97	`}`

func MockcacheMockRecorder.PutLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

108	`func (mr MockcacheMockRecorder) PutLink(arg0, arg1 any) gomock.Call {`
109	`mr.mock.ctrl.T.Helper()`
110	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLink", reflect.TypeOf((*Mockcache)(nil).PutLink), arg0, arg1)`
111	`}`

func Mockdatabase.EXPECT

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

41	`func (m Mockdatabase) EXPECT() MockdatabaseMockRecorder {`
42	`return m.recorder`
43	`}`

func Mockcache.EXPECT

Back

In /home/runner/work/go-tiny-url/go-tiny-url/internal/domain/usecase/fetch/mocks/contract.go:

80	`func (m Mockcache) EXPECT() MockcacheMockRecorder {`
81	`return m.recorder`
82	`}`

Package Overview: github.com/xgmsx/go-tiny-url/pkg/grpc 92.3%

Please select a function to see what's left for testing.

`New(...)`	`github.com/xgmsx/go-tiny-url/pkg/grpc/server.go`	`100.0%`	`5/5`
`Server.Close(...)`	`github.com/xgmsx/go-tiny-url/pkg/grpc/server.go`	`100.0%`	`2/2`
`Server.Serve(...)`	`github.com/xgmsx/go-tiny-url/pkg/grpc/server.go`	`83.3%`	`5/6`

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/grpc/server.go:

func New(controllers ...registrable) *Server {
        srv := grpc.NewServer()

        for _, c := range controllers {
                c.Register(srv)
        }
        reflection.Register(srv)

        return &Server{srv: srv}
}

func Server.Close

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/grpc/server.go:

48	`func (s *Server) Close() {`
49	`s.srv.GracefulStop()`
50	`log.Info().Msg("gRPC server closed")`
51	`}`

func Server.Serve

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/grpc/server.go:

func (s *Server) Serve(ctx context.Context, port string) error {
        var lc net.ListenConfig

        lis, err := lc.Listen(ctx, "tcp", ":"+port)
        if err != nil {
                return err
        }

        log.Info().Msg("gRPC server started on port: " + port)
        return s.srv.Serve(lis)
}

Package Overview: github.com/xgmsx/go-tiny-url/pkg/http 0.0%

Please select a function to see what's left for testing.

`New(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/server.go`	`0.0%`	`0/13`
`defaultOptions(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/options.go`	`0.0%`	`0/9`
`@60:9(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/options.go`	`0.0%`	`0/4`
`Server.Close(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/server.go`	`0.0%`	`0/4`
`DefaultErrorHandler(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/handler.go`	`0.0%`	`0/3`
`Server.Serve(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/server.go`	`0.0%`	`0/2`
`WithMiddleware(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/options.go`	`0.0%`	`0/1`
`@54:19(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/server.go`	`0.0%`	`0/1`
`@55:20(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/server.go`	`0.0%`	`0/1`

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/server.go:

func New(c Config, opts *Options, controllers ...registrable) *Server {
        options := defaultOptions(c, opts)

        app := fiber.New(fiber.Config{
                ErrorHandler:          DefaultErrorHandler,
                AppName:               c.AppName,
                ReadTimeout:           options.ReadTimeout,
                WriteTimeout:          options.WriteTimeout,
                DisableStartupMessage: true,
        })

        for _, m := range options.Middlewares {
                app.Use(m)
        }

        for _, c := range controllers {
                c.Register(app)
        }

        app.Get("/live", func(c *fiber.Ctx) error { return c.SendStatus(fiber.StatusOK) })
        app.Get("/ready", func(c *fiber.Ctx) error { return c.SendStatus(fiber.StatusOK) })
        app.Get("/swagger/*", swagger.HandlerDefault)
        app.Get("/metrics", metrics.HandlerDefault)

        docs.SwaggerInfo.Title = c.AppName
        docs.SwaggerInfo.Version = c.AppVersion

        return &Server{
                App:     app,
                options: options,
        }
}

func defaultOptions

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/options.go:

func defaultOptions(c Config, options ...*Options) *Options {
        if len(options) > 0 && options[0] != nil {
                return options[0]
        }

        mc := metrics.Config{ServiceName: c.AppName, Registry: prometheus.DefaultRegisterer}
        tc := traces.Config{ServerName: c.AppName, CollectClientIP: true}
        tc.SetSkipPaths("/metrics", "/live", "/ready")

        o := &Options{
                ReadTimeout:  readTimeout,
                WriteTimeout: writeTimeout,
                CloseTimeout: closeTimeout,
        }

        for _, opt := range []Option{
                WithMiddleware(requestid.New(requestid.Config{}), c.UseRequestID),
                WithMiddleware(pprof.New(pprof.Config{}), c.UsePprof),
                WithMiddleware(traces.New(tc)),
                WithMiddleware(metrics.New(mc)),
                WithMiddleware(recover.New(recover.Config{}), c.UseRecover),
        } {
                opt(o)
        }

        return o
}

func @60:9

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/options.go:

func(options *Options) {
                for _, v := range conditions {
                        if !v {
                                return
                        }
                }

                options.Middlewares = append(options.Middlewares, m)
        }

func Server.Close

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/server.go:

func (s *Server) Close() {
        err := s.App.ShutdownWithTimeout(s.options.CloseTimeout)
        if err != nil {
                log.Error().Err(err).Msg("Server - Close - s.app.ShutdownWithTimeout")
        }

        log.Info().Msg("HTTP server closed")
}

func DefaultErrorHandler

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/handler.go:

func DefaultErrorHandler(c *fiber.Ctx, err error) error {
        if e, ok := err.(*fiber.Error); ok {
                return c.Status(e.Code).JSON(ErrHTTP{Error: e.Message})
        }
        return c.Status(fiber.StatusInternalServerError).JSON(
                ErrHTTP{Error: http.StatusText(fiber.StatusInternalServerError)})
}

func Server.Serve

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/server.go:

68	`func (s *Server) Serve(port string) error {`
69	`log.Info().Msg("HTTP server started on port: " + port)`
70	`return s.App.Listen("0.0.0.0:" + port)`
71	`}`

func WithMiddleware

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/options.go:

func WithMiddleware(m fiber.Handler, conditions ...bool) Option {
        return func(options *Options) {
                for _, v := range conditions {
                        if !v {
                                return
                        }
                }

                options.Middlewares = append(options.Middlewares, m)
        }
}

func @54:19

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/server.go:

54	`func(c *fiber.Ctx) error { return c.SendStatus(fiber.StatusOK) }`

func @55:20

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/server.go:

55	`func(c *fiber.Ctx) error { return c.SendStatus(fiber.StatusOK) }`

Package Overview: github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics 100.0%

Please select a function to see what's left for testing.

`@39:9(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics/middleware.go`	`100.0%`	`18/18`
`configDefault(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics/config.go`	`100.0%`	`12/12`
`getMetrics(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics/metrics.go`	`100.0%`	`10/10`
`Config.SetSkipPaths(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics/config.go`	`100.0%`	`5/5`
`New(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics/middleware.go`	`100.0%`	`5/5`
`NewHandler(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics/middleware.go`	`100.0%`	`4/4`
`@23:9(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics/middleware.go`	`100.0%`	`1/1`
`@56:9(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/metrics/middleware.go`	`100.0%`	`1/1`

func @39:9

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/metrics/middleware.go:

func(c *fiber.Ctx) (err error) {
                // Пропустить, если функция Next() вернет true
                if cfg.Next != nil && cfg.Next(c) {
                        return c.Next()
                }

                // Пропустить, если путь указан в списке исключений
                path := string(c.Request().RequestURI())
                if _, exists := cfg.skipPaths[path]; exists {
                        return c.Next()
                }

                start := time.Now()
                method := utils.CopyString(c.Route().Method)

                // Изменение метрики http_requests_in_progress_total
                requestsInProgress.WithLabelValues(method, path).Inc()
                defer func() { requestsInProgress.WithLabelValues(method, path).Dec() }()

                // Выполнение запроса
                status := fiber.StatusInternalServerError
                if err = c.Next(); err == nil {
                        status = c.Response().StatusCode()

                        // Изменение метрики http_requests_duration если запрос успешный
                        duration := float64(time.Since(start).Microseconds()) / 1e6
                        requestsDuration.WithLabelValues(strconv.Itoa(status), method, path).Observe(duration)
                } else {
                        if e, ok := err.(*fiber.Error); ok {
                                status = e.Code
                        }
                }

                // Изменение метрики http_requests_total
                requestsTotal.WithLabelValues(strconv.Itoa(status), method, path).Inc()

                return err
        }

func configDefault

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/metrics/config.go:

func configDefault(config ...Config) Config {
        // Return default config if nothing provided
        if len(config) < 1 {
                return ConfigDefault
        }

        // Override default config
        cfg := config[0]

        // Set default values
        if cfg.skipPaths == nil {
                cfg.skipPaths = ConfigDefault.skipPaths
        }
        if cfg.DurationBuckets == nil {
                cfg.DurationBuckets = ConfigDefault.DurationBuckets
        }
        if cfg.Registry == nil {
                cfg.Registry = ConfigDefault.Registry
        }
        if cfg.Next == nil {
                cfg.Next = ConfigDefault.Next
        }

        return cfg
}

func getMetrics

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/metrics/metrics.go:

func getMetrics(registrer prometheus.Registerer, serviceName string, labels map[string]string) (
        total *prometheus.CounterVec, duration *prometheus.HistogramVec, inProgress *prometheus.GaugeVec,
) {
        registry = registrer
        constLabels := make(prometheus.Labels)
        if serviceName != "" {
                constLabels["service"] = serviceName
        }
        for label, value := range labels {
                constLabels[label] = value
        }

        total = promauto.With(registry).NewCounterVec(
                prometheus.CounterOpts{
                        Name:        "http_requests_total",
                        Help:        "Count all http requests by status code, method and path.",
                        ConstLabels: constLabels,
                },
                []string{"status", "method", "path"},
        )

        duration = promauto.With(registry).NewHistogramVec(
                prometheus.HistogramOpts{
                        Name:        "http_requests_duration",
                        Help:        "Duration of all HTTP requests by status code, method and path.",
                        ConstLabels: constLabels,
                        Buckets:     defaultBuckets,
                },
                []string{"status", "method", "path"},
        )

        inProgress = promauto.With(registry).NewGaugeVec(
                prometheus.GaugeOpts{
                        Name:        "http_requests_in_progress_total",
                        Help:        "All the requests in progress by method and path",
                        ConstLabels: constLabels,
                }, []string{"method", "path"},
        )

        return total, duration, inProgress
}

func Config.SetSkipPaths

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/metrics/config.go:

func (c *Config) SetSkipPaths(paths ...string) *Config {
        if len(paths) > 0 {
                c.skipPaths = make(map[string]struct{}, len(paths))
                for _, path := range paths {
                        c.skipPaths[path] = struct{}{}
                }
        }
        return c
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/metrics/middleware.go:

func New(config ...Config) fiber.Handler {
        // Set default config
        cfg := configDefault(config...)
        if cfg.Registry == nil {
                cfg.Registry = prometheus.NewRegistry()
        }

        // Initializing metrics
        requestsTotal, requestsDuration, requestsInProgress := getMetrics(cfg.Registry, cfg.ServiceName, cfg.Labels)

        // Return middleware handler
        return func(c *fiber.Ctx) (err error) {
                // Пропустить, если функция Next() вернет true
                if cfg.Next != nil && cfg.Next(c) {
                        return c.Next()
                }

                // Пропустить, если путь указан в списке исключений
                path := string(c.Request().RequestURI())
                if _, exists := cfg.skipPaths[path]; exists {
                        return c.Next()
                }

                start := time.Now()
                method := utils.CopyString(c.Route().Method)

                // Изменение метрики http_requests_in_progress_total
                requestsInProgress.WithLabelValues(method, path).Inc()
                defer func() { requestsInProgress.WithLabelValues(method, path).Dec() }()

                // Выполнение запроса
                status := fiber.StatusInternalServerError
                if err = c.Next(); err == nil {
                        status = c.Response().StatusCode()

                        // Изменение метрики http_requests_duration если запрос успешный
                        duration := float64(time.Since(start).Microseconds()) / 1e6
                        requestsDuration.WithLabelValues(strconv.Itoa(status), method, path).Observe(duration)
                } else {
                        if e, ok := err.(*fiber.Error); ok {
                                status = e.Code
                        }
                }

                // Изменение метрики http_requests_total
                requestsTotal.WithLabelValues(strconv.Itoa(status), method, path).Inc()

                return err
        }
}

func NewHandler

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/metrics/middleware.go:

func NewHandler() fiber.Handler {
        gatherer := prometheus.DefaultGatherer
        if g, ok := registry.(prometheus.Gatherer); ok && g != gatherer {
                gatherer = g
        }

        return func(c *fiber.Ctx) error {
                return adaptor.HTTPHandler(promhttp.HandlerFor(gatherer, promhttp.HandlerOpts{}))(c)
        }
}

func @23:9

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/metrics/middleware.go:

23	`func(c *fiber.Ctx) error {`
24	`return adaptor.HTTPHandler(promhttp.HandlerFor(gatherer, promhttp.HandlerOpts{}))(c)`
25	`}`

func @56:9

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/metrics/middleware.go:

56	`func() { requestsInProgress.WithLabelValues(method, path).Dec() }`

Package Overview: github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces 100.0%

Please select a function to see what's left for testing.

`@43:9(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces/middleware.go`	`100.0%`	`23/23`
`getTraceAttributesFromRequest(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces/middleware.go`	`100.0%`	`10/10`
`New(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces/middleware.go`	`100.0%`	`9/9`
`getTraceAttributesFromResponse(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces/middleware.go`	`100.0%`	`7/7`
`configDefault(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces/config.go`	`100.0%`	`6/6`
`Config.SetSkipPaths(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces/config.go`	`100.0%`	`5/5`
`@66:31(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces/middleware.go`	`100.0%`	`1/1`
`defaultSpanNameFormatter(...)`	`github.com/xgmsx/go-tiny-url/pkg/http/middlewares/traces/middleware.go`	`100.0%`	`1/1`

func @43:9

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/traces/middleware.go:

func(c *fiber.Ctx) (err error) {
                // Пропустить, если функция Next() вернет true
                if cfg.Next != nil && cfg.Next(c) {
                        return c.Next()
                }

                // Пропустить, если путь указан в списке исключений
                if _, exists := cfg.skipPaths[string(c.Request().RequestURI())]; exists {
                        return c.Next()
                }

                // before request
                spanName := cfg.SpanNameFormatter(c)
                spanOpts := []oteltrace.SpanStartOption{
                        oteltrace.WithAttributes(getTraceAttributesFromRequest(c, &cfg)...),
                        oteltrace.WithSpanKind(oteltrace.SpanKindServer),
                }

                reqCtx := c.UserContext()
                defer c.SetUserContext(reqCtx)

                // extract TraceID from headers
                reqHeaders := make(http.Header, requestHeadersLen)
                c.Request().Header.VisitAll(func(k, v []byte) { reqHeaders.Add(string(k), string(v)) })
                ctx := cfg.Propagators.Extract(reqCtx, propagation.HeaderCarrier(reqHeaders))

                // create span
                spanCtx, span := tracer.Start(ctx, spanName, spanOpts...)
                defer span.End()
                c.SetUserContext(spanCtx)

                // request
                if err = c.Next(); err != nil {
                        span.RecordError(err)
                }

                // inject TraceID into headers
                respHeaders := make(propagation.HeaderCarrier, 1)
                cfg.Propagators.Inject(spanCtx, respHeaders)
                for _, headerKey := range respHeaders.Keys() {
                        c.Set(headerKey, respHeaders.Get(headerKey))
                }

                // after request
                span.SetAttributes(getTraceAttributesFromResponse(c)...)
                span.SetStatus(semconv.SpanStatusFromHTTPStatusCodeAndSpanKind(
                        c.Response().StatusCode(), oteltrace.SpanKindServer))

                return err
        }

func getTraceAttributesFromRequest

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/traces/middleware.go:

func getTraceAttributesFromRequest(c *fiber.Ctx, cfg *Config) []attribute.KeyValue {
        attrs := make([]attribute.KeyValue, 0, requestAttributesLen)
        attrs = append(attrs,
                semconv.HTTPRequestContentLengthKey.Int(c.Request().Header.ContentLength()),
                semconv.HTTPMethodKey.String(utils.CopyString(c.Method())),
                semconv.HTTPSchemeKey.String(utils.CopyString(c.Protocol())),
                semconv.HTTPTargetKey.String(string(utils.CopyBytes(c.Request().RequestURI()))),
                semconv.HTTPURLKey.String(utils.CopyString(c.OriginalURL())),
                semconv.HTTPUserAgentKey.String(string(utils.CopyBytes(c.Request().Header.UserAgent()))),
                semconv.NetHostNameKey.String(utils.CopyString(c.Hostname())),
                semconv.NetTransportTCP,
        )

        if cfg.ServerName != "" {
                attrs = append(attrs, semconv.HTTPServerNameKey.String(cfg.ServerName))
        }

        if cfg.ServerPort != 0 {
                attrs = append(attrs, semconv.NetHostPortKey.Int(cfg.ServerPort))
        }

        if cfg.CollectClientIP {
                if clientIP := c.IP(); clientIP != "" {
                        attrs = append(attrs, semconv.HTTPClientIPKey.String(utils.CopyString(clientIP)))
                }
        }

        return attrs
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/traces/middleware.go:

func New(config ...Config) fiber.Handler {
        // Set default config
        cfg := configDefault(config...)
        if cfg.TracerProvider == nil {
                cfg.TracerProvider = otel.GetTracerProvider()
        }

        // Initializing
        tracer := cfg.TracerProvider.Tracer("fiber",
                oteltrace.WithInstrumentationVersion(otelcontrib.Version()),
        )

        if cfg.Propagators == nil {
                cfg.Propagators = otel.GetTextMapPropagator()
        }
        if cfg.SpanNameFormatter == nil {
                cfg.SpanNameFormatter = defaultSpanNameFormatter
        }

        // Return new handler
        return func(c *fiber.Ctx) (err error) {
                // Пропустить, если функция Next() вернет true
                if cfg.Next != nil && cfg.Next(c) {
                        return c.Next()
                }

                // Пропустить, если путь указан в списке исключений
                if _, exists := cfg.skipPaths[string(c.Request().RequestURI())]; exists {
                        return c.Next()
                }

                // before request
                spanName := cfg.SpanNameFormatter(c)
                spanOpts := []oteltrace.SpanStartOption{
                        oteltrace.WithAttributes(getTraceAttributesFromRequest(c, &cfg)...),
                        oteltrace.WithSpanKind(oteltrace.SpanKindServer),
                }

                reqCtx := c.UserContext()
                defer c.SetUserContext(reqCtx)

                // extract TraceID from headers
                reqHeaders := make(http.Header, requestHeadersLen)
                c.Request().Header.VisitAll(func(k, v []byte) { reqHeaders.Add(string(k), string(v)) })
                ctx := cfg.Propagators.Extract(reqCtx, propagation.HeaderCarrier(reqHeaders))

                // create span
                spanCtx, span := tracer.Start(ctx, spanName, spanOpts...)
                defer span.End()
                c.SetUserContext(spanCtx)

                // request
                if err = c.Next(); err != nil {
                        span.RecordError(err)
                }

                // inject TraceID into headers
                respHeaders := make(propagation.HeaderCarrier, 1)
                cfg.Propagators.Inject(spanCtx, respHeaders)
                for _, headerKey := range respHeaders.Keys() {
                        c.Set(headerKey, respHeaders.Get(headerKey))
                }

                // after request
                span.SetAttributes(getTraceAttributesFromResponse(c)...)
                span.SetStatus(semconv.SpanStatusFromHTTPStatusCodeAndSpanKind(
                        c.Response().StatusCode(), oteltrace.SpanKindServer))

                return err
        }
}

func getTraceAttributesFromResponse

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/traces/middleware.go:

func getTraceAttributesFromResponse(c *fiber.Ctx) []attribute.KeyValue {
        var responseSize int64
        if c.GetRespHeader("Content-Type") != "text/event-stream" {
                responseSize = int64(len(c.Response().Body()))
        }

        attrs := make([]attribute.KeyValue, 0, responseAttributesLen)
        attrs = append(attrs, semconv.HTTPAttributesFromHTTPStatusCode(c.Response().StatusCode())...)
        attrs = append(attrs,
                semconv.HTTPResponseContentLengthKey.Int64(responseSize),
                semconv.HTTPRouteKey.String(c.Route().Path),
        )

        return attrs
}

func configDefault

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/traces/config.go:

func configDefault(config ...Config) Config {
        // Return default config if nothing provided
        if len(config) < 1 {
                return ConfigDefault
        }

        // Override default config
        cfg := config[0]

        // Set default values
        if cfg.skipPaths == nil {
                cfg.skipPaths = ConfigDefault.skipPaths
        }

        return cfg
}

func Config.SetSkipPaths

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/traces/config.go:

func (c *Config) SetSkipPaths(paths ...string) *Config {
        if len(paths) > 0 {
                c.skipPaths = make(map[string]struct{}, len(paths))
                for _, path := range paths {
                        c.skipPaths[path] = struct{}{}
                }
        }
        return c
}

func @66:31

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/traces/middleware.go:

66	`func(k, v []byte) { reqHeaders.Add(string(k), string(v)) }`

func defaultSpanNameFormatter

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/http/middlewares/traces/middleware.go:

95	`func defaultSpanNameFormatter(c *fiber.Ctx) string {`
96	`return string(utils.CopyBytes(c.Request().RequestURI()))`
97	`}`

Package Overview: github.com/xgmsx/go-tiny-url/pkg/kafka/reader 0.0%

Please select a function to see what's left for testing.

`Reader.Close(...)`	`github.com/xgmsx/go-tiny-url/pkg/kafka/reader/reader.go`	`0.0%`	`0/4`
`New(...)`	`github.com/xgmsx/go-tiny-url/pkg/kafka/reader/reader.go`	`0.0%`	`0/2`

func Reader.Close

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/kafka/reader/reader.go:

func (r *Reader) Close() {
        err := r.Reader.Close()
        if err != nil {
                log.Error().Err(err).Msg("kafka - r.Reader.Close")
        }

        log.Info().Msg("Kafka reader closed")
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/kafka/reader/reader.go:

func New(c *Config) (*Reader, error) {
        r := kafka.NewReader(kafka.ReaderConfig{
                Brokers:  c.Addr,
                GroupID:  c.Group,
                Topic:    c.Topic,
                MaxBytes: 10e6, // 10MB
        })

        return &Reader{Reader: r}, nil
}

Package Overview: github.com/xgmsx/go-tiny-url/pkg/kafka/writer 0.0%

Please select a function to see what's left for testing.

`Writer.Close(...)`	`github.com/xgmsx/go-tiny-url/pkg/kafka/writer/writer.go`	`0.0%`	`0/4`
`New(...)`	`github.com/xgmsx/go-tiny-url/pkg/kafka/writer/writer.go`	`0.0%`	`0/2`

func Writer.Close

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/kafka/writer/writer.go:

func (w *Writer) Close() {
        err := w.Writer.Close()
        if err != nil {
                log.Error().Err(err).Msg("kafka - w.Writer.Close")
        }

        log.Info().Msg("Kafka writer closed")
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/kafka/writer/writer.go:

func New(c *Config) (*Writer, error) {
        w := &kafka.Writer{
                Addr:     kafka.TCP(c.Addr...),
                Topic:    c.Topic,
                Balancer: &kafka.LeastBytes{},
        }

        return &Writer{Writer: w}, nil
}

Package Overview: github.com/xgmsx/go-tiny-url/pkg/logger 77.8%

Please select a function to see what's left for testing.

Init(...) github.com/xgmsx/go-tiny-url/pkg/logger/logger.go 77.8% 7/9

func Init

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/logger/logger.go:

func Init(c Config, name, version string) {
        zerolog.TimeFieldFormat = time.RFC3339
        zerolog.SetGlobalLevel(zerolog.InfoLevel)

        level, err := zerolog.ParseLevel(c.Level)
        if err != nil {
                zerolog.SetGlobalLevel(level)
        }

        if c.PrettyConsole {
                log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr, TimeFormat: "15:04:05"})
        } else {
                log.Logger = log.With().
                        Caller().
                        Str("app_name", name).
                        Str("app_version", version).
                        Logger()
        }

        log.Info().Msg("Logger initialized")
}

Package Overview: github.com/xgmsx/go-tiny-url/pkg/observability/otel 34.5%

Please select a function to see what's left for testing.

`Init(...)`	`github.com/xgmsx/go-tiny-url/pkg/observability/otel/otel.go`	`38.1%`	`8/21`
`Close(...)`	`github.com/xgmsx/go-tiny-url/pkg/observability/otel/otel.go`	`25.0%`	`2/8`

func Init

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/observability/otel/otel.go:

func Init(ctx context.Context, c Config, name, version string) {
        otel.SetTextMapPropagator(
                propagation.NewCompositeTextMapPropagator(
                        propagation.TraceContext{},
                        propagation.Baggage{},
                ))

        var exporter *otlptrace.Exporter
        var err error

        switch {
        case c.Endpoint != "":
                exporter, err = otlptracegrpc.New(ctx,
                        otlptracegrpc.WithEndpoint(c.Endpoint),
                        otlptracegrpc.WithInsecure())
                if err != nil {
                        log.Error().Err(err).Msg("Tracer initialization failed")
                        return
                }
        case c.EndpointHTTP != "":
                exporter, err = otlptracehttp.New(ctx,
                        otlptracehttp.WithEndpoint(c.EndpointHTTP),
                        otlptracehttp.WithInsecure())
                if err != nil {
                        log.Error().Err(err).Msg("Tracer initialization failed")
                        return
                }
        default:
                otel.SetTracerProvider(tracer_noop.NewTracerProvider())
                tracer.Init(otel.Tracer(""))
                log.Info().Msg("Tracer is disabled")
                return
        }

        traceProvider := trace.NewTracerProvider(
                trace.WithBatcher(exporter, trace.WithBatchTimeout(time.Second)),
                trace.WithResource(resource.NewWithAttributes(
                        semconv.SchemaURL,
                        semconv.ServiceNameKey.String(name),
                        semconv.ServiceVersionKey.String(version),
                        semconv.ServiceNamespaceKey.String(c.Namespace),
                        semconv.ServiceInstanceIDKey.String(c.InstanceID),
                )),
        )

        shutdownTracing = traceProvider.Shutdown
        otel.SetTracerProvider(traceProvider)
        tracer.Init(otel.Tracer("app"))
        log.Info().Msg("Tracer initialized")
}

func Close

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/observability/otel/otel.go:

func Close() {
        if shutdownTracing == nil {
                return
        }

        ctx, stop := context.WithTimeout(context.Background(), closeTimeout)
        defer stop()

        err := shutdownTracing(ctx)
        if err != nil {
                log.Error().Err(err).Msg("Tracer shutdown failed")
        }

        log.Info().Msg("Tracer closed")
}

Package Overview: github.com/xgmsx/go-tiny-url/pkg/observability/otel/tracer 50.0%

Please select a function to see what's left for testing.

`init(...)`	`github.com/xgmsx/go-tiny-url/pkg/observability/otel/tracer/tracer.go`	`100.0%`	`1/1`
`Init(...)`	`github.com/xgmsx/go-tiny-url/pkg/observability/otel/tracer/tracer.go`	`100.0%`	`1/1`
`Start(...)`	`github.com/xgmsx/go-tiny-url/pkg/observability/otel/tracer/tracer.go`	`100.0%`	`1/1`
`SetStatus(...)`	`github.com/xgmsx/go-tiny-url/pkg/observability/otel/tracer/tracer.go`	`0.0%`	`0/3`

func init

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/observability/otel/tracer/tracer.go:

14	`func init() { // nolint // default tracer`
15	`tracer = otel.Tracer("")`
16	`}`

func Init

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/observability/otel/tracer/tracer.go:

18	`func Init(t trace.Tracer) {`
19	`tracer = t`
20	`}`

func Start

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/observability/otel/tracer/tracer.go:

22	`func Start(ctx context.Context, spanName string, opts ...trace.SpanStartOption) (context.Context, trace.Span) {`
23	`return tracer.Start(ctx, spanName, opts...)`
24	`}`

func SetStatus

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/observability/otel/tracer/tracer.go:

func SetStatus(span trace.Span, err error) {
        if err != nil {
                span.SetStatus(codes.Error, err.Error())
        } else {
                span.SetStatus(codes.Ok, "")
        }
}

Package Overview: github.com/xgmsx/go-tiny-url/pkg/observability/sentry 50.0%

Please select a function to see what's left for testing.

`Close(...)`	`github.com/xgmsx/go-tiny-url/pkg/observability/sentry/sentry.go`	`100.0%`	`2/2`
`Init(...)`	`github.com/xgmsx/go-tiny-url/pkg/observability/sentry/sentry.go`	`37.5%`	`3/8`

func Close

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/observability/sentry/sentry.go:

42	`func Close() {`
43	`_ = sentry.Flush(closeTimeout)`
44	`log.Info().Msg("Sentry closed")`
45	`}`

func Init

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/observability/sentry/sentry.go:

func Init(c Config, name, version, env string) {
        if c.DSN == "" {
                log.Info().Msg("Sentry is disabled")
                return
        }

        err := sentry.Init(sentry.ClientOptions{
                Dsn:              c.DSN,
                SampleRate:       c.Rate,
                AttachStacktrace: c.AttachStackTrace,
                Debug:            c.Debug,
                ServerName:       name,
                Release:          version,
                Environment:      env,
        })
        if err != nil {
                log.Error().Err(err).Msg("Sentry initialization failed")
                return
        }

        log.Info().Msg("Sentry initialized")
}

Package Overview: github.com/xgmsx/go-tiny-url/pkg/postgres 0.0%

Please select a function to see what's left for testing.

`New(...)`	`github.com/xgmsx/go-tiny-url/pkg/postgres/postgres.go`	`0.0%`	`0/8`
`Pool.Close(...)`	`github.com/xgmsx/go-tiny-url/pkg/postgres/postgres.go`	`0.0%`	`0/2`

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/postgres/postgres.go:

func New(ctx context.Context, c *Config) (*Pool, error) {
        dsn := fmt.Sprintf("user=%s password=%s port=%s host=%s dbname=%s",
                c.User, c.Password, c.Port, c.Host, c.DBName)

        cfg, err := pgxpool.ParseConfig(dsn)
        if err != nil {
                return nil, fmt.Errorf("pgxpool.ParseConfig: %w", err)
        }

        pool, err := pgxpool.NewWithConfig(ctx, cfg)
        if err != nil {
                return nil, fmt.Errorf("pgxpool.NewWithConfig: %w", err)
        }

        return &Pool{Pool: pool}, nil
}

func Pool.Close

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/postgres/postgres.go:

40	`func (p *Pool) Close() {`
41	`p.Pool.Close()`
42	`log.Info().Msg("Postgres closed")`
43	`}`

Package Overview: github.com/xgmsx/go-tiny-url/pkg/redis 0.0%

Please select a function to see what's left for testing.

`Client.Close(...)`	`github.com/xgmsx/go-tiny-url/pkg/redis/redis.go`	`0.0%`	`0/4`
`New(...)`	`github.com/xgmsx/go-tiny-url/pkg/redis/redis.go`	`0.0%`	`0/2`

func Client.Close

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/redis/redis.go:

func (c *Client) Close() {
        err := c.Client.Close()
        if err != nil {
                log.Error().Err(err).Msg("redis.Close")
        }

        log.Info().Msg("Redis closed")
}

func New

Back

In /home/runner/work/go-tiny-url/go-tiny-url/pkg/redis/redis.go:

func New(c *Config) (*Client, error) {
        client := redis.NewClient(&redis.Options{
                Addr:     c.Addr,
                Password: c.Password,
                DB:       c.DB,
        })

        return &Client{Client: client}, nil
}

Package Overview: github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1 12.1%

Please select a function to see what's left for testing.

`RegisterShortenerServer(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`100.0%`	`3/3`
`init(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`100.0%`	`1/1`
`file_shortener_v1_proto_init(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`87.5%`	`7/8`
`FetchLinkRequest.GetAlias(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`66.7%`	`2/3`
`CreateLinkRequest.GetUrl(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`66.7%`	`2/3`
`_Shortener_FetchLink_Handler(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/8`
`_Shortener_CreateLink_Handler(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/8`
`FetchLinkRequest.ProtoReflect(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/7`
`CreateLinkRequest.ProtoReflect(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/7`
`CreateLinkResponse.ProtoReflect(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/7`
`FetchLinkResponse.ProtoReflect(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/7`
`shortenerClient.FetchLink(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/6`
`shortenerClient.CreateLink(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/6`
`CreateLinkRequest.Reset(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/4`
`FetchLinkRequest.Reset(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/4`
`FetchLinkResponse.Reset(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/4`
`CreateLinkResponse.Reset(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/4`
`CreateLinkResponse.GetUrl(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/3`
`FetchLinkResponse.GetUrl(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/3`
`CreateLinkResponse.GetAlias(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/3`
`FetchLinkResponse.GetExpiredAt(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/3`
`FetchLinkResponse.GetAlias(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/3`
`CreateLinkResponse.GetExpiredAt(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/3`
`file_shortener_v1_proto_rawDescGZIP(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/2`
`FetchLinkResponse.Descriptor(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`CreateLinkResponse.Descriptor(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`@136:13(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/1`
`FetchLinkResponse.String(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`FetchLinkRequest.String(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`@281:41(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`CreateLinkRequest.String(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`CreateLinkRequest.Descriptor(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`NewShortenerClient(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/1`
`FetchLinkRequest.Descriptor(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`CreateLinkResponse.String(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`0.0%`	`0/1`
`UnimplementedShortenerServer.CreateLink(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/1`
`UnimplementedShortenerServer.FetchLink(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/1`
`@118:13(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`0.0%`	`0/1`
`CreateLinkResponse.ProtoMessage(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`100.0%`	`0/0`
`UnimplementedShortenerServer.testEmbeddedByValue(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`100.0%`	`0/0`
`CreateLinkRequest.ProtoMessage(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`100.0%`	`0/0`
`UnimplementedShortenerServer.mustEmbedUnimplementedShortenerServer(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go`	`100.0%`	`0/0`
`FetchLinkRequest.ProtoMessage(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`100.0%`	`0/0`
`FetchLinkResponse.ProtoMessage(...)`	`github.com/xgmsx/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go`	`100.0%`	`0/0`

func RegisterShortenerServer

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

func RegisterShortenerServer(s grpc.ServiceRegistrar, srv ShortenerServer) {
        // If the following call pancis, it indicates UnimplementedShortenerServer was
        // embedded by pointer and is nil.  This will cause panics if an
        // unimplemented method is ever invoked, so we test this at initialization
        // time to prevent it from happening at runtime later due to I/O.
        if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
                t.testEmbeddedByValue()
        }
        s.RegisterService(&Shortener_ServiceDesc, srv)
}

func init

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

309	`func init() { file_shortener_v1_proto_init() }`

func file_shortener_v1_proto_init

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func file_shortener_v1_proto_init() {
        if File_shortener_v1_proto != nil {
                return
        }
        type x struct{}
        out := protoimpl.TypeBuilder{
                File: protoimpl.DescBuilder{
                        GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
                        RawDescriptor: file_shortener_v1_proto_rawDesc,
                        NumEnums:      0,
                        NumMessages:   4,
                        NumExtensions: 0,
                        NumServices:   1,
                },
                GoTypes:           file_shortener_v1_proto_goTypes,
                DependencyIndexes: file_shortener_v1_proto_depIdxs,
                MessageInfos:      file_shortener_v1_proto_msgTypes,
        }.Build()
        File_shortener_v1_proto = out.File
        file_shortener_v1_proto_rawDesc = nil
        file_shortener_v1_proto_goTypes = nil
        file_shortener_v1_proto_depIdxs = nil
}

func FetchLinkRequest.GetAlias

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *FetchLinkRequest) GetAlias() string {
        if x != nil {
                return x.Alias
        }
        return ""
}

func CreateLinkRequest.GetUrl

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *CreateLinkRequest) GetUrl() string {
        if x != nil {
                return x.Url
        }
        return ""
}

func _Shortener_FetchLink_Handler

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

func _Shortener_FetchLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(FetchLinkRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(ShortenerServer).FetchLink(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: Shortener_FetchLink_FullMethodName,
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(ShortenerServer).FetchLink(ctx, req.(*FetchLinkRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func _Shortener_CreateLink_Handler

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

func _Shortener_CreateLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
        in := new(CreateLinkRequest)
        if err := dec(in); err != nil {
                return nil, err
        }
        if interceptor == nil {
                return srv.(ShortenerServer).CreateLink(ctx, in)
        }
        info := &grpc.UnaryServerInfo{
                Server:     srv,
                FullMethod: Shortener_CreateLink_FullMethodName,
        }
        handler := func(ctx context.Context, req interface{}) (interface{}, error) {
                return srv.(ShortenerServer).CreateLink(ctx, req.(*CreateLinkRequest))
        }
        return interceptor(ctx, in, info, handler)
}

func FetchLinkRequest.ProtoReflect

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *FetchLinkRequest) ProtoReflect() protoreflect.Message {
        mi := &file_shortener_v1_proto_msgTypes[2]
        if x != nil {
                ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
                if ms.LoadMessageInfo() == nil {
                        ms.StoreMessageInfo(mi)
                }
                return ms
        }
        return mi.MessageOf(x)
}

func CreateLinkRequest.ProtoReflect

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *CreateLinkRequest) ProtoReflect() protoreflect.Message {
        mi := &file_shortener_v1_proto_msgTypes[0]
        if x != nil {
                ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
                if ms.LoadMessageInfo() == nil {
                        ms.StoreMessageInfo(mi)
                }
                return ms
        }
        return mi.MessageOf(x)
}

func CreateLinkResponse.ProtoReflect

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *CreateLinkResponse) ProtoReflect() protoreflect.Message {
        mi := &file_shortener_v1_proto_msgTypes[1]
        if x != nil {
                ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
                if ms.LoadMessageInfo() == nil {
                        ms.StoreMessageInfo(mi)
                }
                return ms
        }
        return mi.MessageOf(x)
}

func FetchLinkResponse.ProtoReflect

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *FetchLinkResponse) ProtoReflect() protoreflect.Message {
        mi := &file_shortener_v1_proto_msgTypes[3]
        if x != nil {
                ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
                if ms.LoadMessageInfo() == nil {
                        ms.StoreMessageInfo(mi)
                }
                return ms
        }
        return mi.MessageOf(x)
}

func shortenerClient.FetchLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

func (c *shortenerClient) FetchLink(ctx context.Context, in *FetchLinkRequest, opts ...grpc.CallOption) (*FetchLinkResponse, error) {
        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
        out := new(FetchLinkResponse)
        err := c.cc.Invoke(ctx, Shortener_FetchLink_FullMethodName, in, out, cOpts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func shortenerClient.CreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

func (c *shortenerClient) CreateLink(ctx context.Context, in *CreateLinkRequest, opts ...grpc.CallOption) (*CreateLinkResponse, error) {
        cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
        out := new(CreateLinkResponse)
        err := c.cc.Invoke(ctx, Shortener_CreateLink_FullMethodName, in, out, cOpts...)
        if err != nil {
                return nil, err
        }
        return out, nil
}

func CreateLinkRequest.Reset

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *CreateLinkRequest) Reset() {
        *x = CreateLinkRequest{}
        mi := &file_shortener_v1_proto_msgTypes[0]
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        ms.StoreMessageInfo(mi)
}

func FetchLinkRequest.Reset

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *FetchLinkRequest) Reset() {
        *x = FetchLinkRequest{}
        mi := &file_shortener_v1_proto_msgTypes[2]
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        ms.StoreMessageInfo(mi)
}

func FetchLinkResponse.Reset

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *FetchLinkResponse) Reset() {
        *x = FetchLinkResponse{}
        mi := &file_shortener_v1_proto_msgTypes[3]
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        ms.StoreMessageInfo(mi)
}

func CreateLinkResponse.Reset

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *CreateLinkResponse) Reset() {
        *x = CreateLinkResponse{}
        mi := &file_shortener_v1_proto_msgTypes[1]
        ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
        ms.StoreMessageInfo(mi)
}

func CreateLinkResponse.GetUrl

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *CreateLinkResponse) GetUrl() string {
        if x != nil {
                return x.Url
        }
        return ""
}

func FetchLinkResponse.GetUrl

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *FetchLinkResponse) GetUrl() string {
        if x != nil {
                return x.Url
        }
        return ""
}

func CreateLinkResponse.GetAlias

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *CreateLinkResponse) GetAlias() string {
        if x != nil {
                return x.Alias
        }
        return ""
}

func FetchLinkResponse.GetExpiredAt

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *FetchLinkResponse) GetExpiredAt() *timestamppb.Timestamp {
        if x != nil {
                return x.ExpiredAt
        }
        return nil
}

func FetchLinkResponse.GetAlias

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *FetchLinkResponse) GetAlias() string {
        if x != nil {
                return x.Alias
        }
        return ""
}

func CreateLinkResponse.GetExpiredAt

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func (x *CreateLinkResponse) GetExpiredAt() *timestamppb.Timestamp {
        if x != nil {
                return x.ExpiredAt
        }
        return nil
}

func file_shortener_v1_proto_rawDescGZIP

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

func file_shortener_v1_proto_rawDescGZIP() []byte {
        file_shortener_v1_proto_rawDescOnce.Do(func() {
                file_shortener_v1_proto_rawDescData = protoimpl.X.CompressGZIP(file_shortener_v1_proto_rawDescData)
        })
        return file_shortener_v1_proto_rawDescData
}

func FetchLinkResponse.Descriptor

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

208	`func (*FetchLinkResponse) Descriptor() ([]byte, []int) {`
209	`return file_shortener_v1_proto_rawDescGZIP(), []int{3}`
210	`}`

func CreateLinkResponse.Descriptor

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

104	`func (*CreateLinkResponse) Descriptor() ([]byte, []int) {`
105	`return file_shortener_v1_proto_rawDescGZIP(), []int{1}`
106	`}`

func @136:13

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

136	`func(ctx context.Context, req interface{}) (interface{}, error) {`
137	`return srv.(ShortenerServer).FetchLink(ctx, req.(*FetchLinkRequest))`
138	`}`

func FetchLinkResponse.String

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

189	`func (x *FetchLinkResponse) String() string {`
190	`return protoimpl.X.MessageStringOf(x)`
191	`}`

func FetchLinkRequest.String

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

143	`func (x *FetchLinkRequest) String() string {`
144	`return protoimpl.X.MessageStringOf(x)`
145	`}`

func @281:41

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

281	`func() {`
282	`file_shortener_v1_proto_rawDescData = protoimpl.X.CompressGZIP(file_shortener_v1_proto_rawDescData)`
283	`}`

func CreateLinkRequest.String

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

39	`func (x *CreateLinkRequest) String() string {`
40	`return protoimpl.X.MessageStringOf(x)`
41	`}`

func CreateLinkRequest.Descriptor

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

58	`func (*CreateLinkRequest) Descriptor() ([]byte, []int) {`
59	`return file_shortener_v1_proto_rawDescGZIP(), []int{0}`
60	`}`

func NewShortenerClient

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

39	`func NewShortenerClient(cc grpc.ClientConnInterface) ShortenerClient {`
40	`return &shortenerClient{cc}`
41	`}`

func FetchLinkRequest.Descriptor

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

162	`func (*FetchLinkRequest) Descriptor() ([]byte, []int) {`
163	`return file_shortener_v1_proto_rawDescGZIP(), []int{2}`
164	`}`

func CreateLinkResponse.String

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

85	`func (x *CreateLinkResponse) String() string {`
86	`return protoimpl.X.MessageStringOf(x)`
87	`}`

func UnimplementedShortenerServer.CreateLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

79	`func (UnimplementedShortenerServer) CreateLink(context.Context, CreateLinkRequest) (CreateLinkResponse, error) {`
80	`return nil, status.Errorf(codes.Unimplemented, "method CreateLink not implemented")`
81	`}`

func UnimplementedShortenerServer.FetchLink

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

82	`func (UnimplementedShortenerServer) FetchLink(context.Context, FetchLinkRequest) (FetchLinkResponse, error) {`
83	`return nil, status.Errorf(codes.Unimplemented, "method FetchLink not implemented")`
84	`}`

func @118:13

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

118	`func(ctx context.Context, req interface{}) (interface{}, error) {`
119	`return srv.(ShortenerServer).CreateLink(ctx, req.(*CreateLinkRequest))`
120	`}`

func CreateLinkResponse.ProtoMessage

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

89	`func (*CreateLinkResponse) ProtoMessage() {}`

func UnimplementedShortenerServer.testEmbeddedByValue

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

86	`func (UnimplementedShortenerServer) testEmbeddedByValue() {}`

func CreateLinkRequest.ProtoMessage

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

43	`func (*CreateLinkRequest) ProtoMessage() {}`

func UnimplementedShortenerServer.mustEmbedUnimplementedShortenerServer

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1_grpc.pb.go:

85	`func (UnimplementedShortenerServer) mustEmbedUnimplementedShortenerServer() {}`

func FetchLinkRequest.ProtoMessage

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

147	`func (*FetchLinkRequest) ProtoMessage() {}`

func FetchLinkResponse.ProtoMessage

Back

In /home/runner/work/go-tiny-url/go-tiny-url/proto/gen/shortener.v1/shortener_v1.pb.go:

193	`func (*FetchLinkResponse) ProtoMessage() {}`

Report Total

57.9%

87	`func (a App) waiting(errCh <-chan error) error {`
88	`log.Info().Msg("App started")`
89	`defer log.Info().Msg("App stopping...")`
90
91	`ctxTerm, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)`
92	`defer stop()`
93
94	`select {`
95	`case <-ctxTerm.Done():`
96	`log.Info().Msg("App got termination signal")`
97	`return nil`
98	`case err := <-errCh:`
99	`log.Info().Err(err).Msg("App got error notify")`
100	`return err`
101	`}`
102	`}`

87	`func (h HandlerFetchLink) Handler(c fiber.Ctx) error {`
88	`ctx, span := tracer.Start(c.Context(), "http/v1 FetchLink")`
89	`defer span.End()`
90
91	`alias := c.Params("alias")`
92
93	`input := dto.FetchLinkInput{Alias: alias}`
94	`if err := input.Validate(); err != nil {`
95	`log.Error().Msg("uc.FetchLink: alias is required")`
96	`return fiber.NewError(fiber.StatusBadRequest, "validation error")`
97	`}`
98
99	`output, err := h.uc.Fetch(ctx, input)`
100	`if err != nil {`
101	`switch {`
102	`case errors.Is(err, entity.ErrNotFound):`
103	`log.Error().Err(err).Msg("uc.FetchLink: not found")`
104	`return fiber.NewError(fiber.StatusNotFound, "not found")`
105	`default:`
106	`log.Error().Err(err).Msg("uc.FetchLink: internal error")`
107	`return fiber.NewError(fiber.StatusInternalServerError, "internal error")`
108	`}`
109	`}`
110
111	`return c.Status(fiber.StatusOK).JSON(output)`
112	`}`

134	`func (h HandlerRedirect) Handler(c fiber.Ctx) error {`
135	`ctx, span := tracer.Start(c.Context(), "http/v1 Redirect")`
136	`defer span.End()`
137
138	`alias := c.Params("alias")`
139
140	`input := dto.FetchLinkInput{Alias: alias}`
141	`if err := input.Validate(); err != nil {`
142	`log.Error().Msg("uc.FetchLink: alias is required")`
143	`return fiber.NewError(fiber.StatusBadRequest, "validation error")`
144	`}`
145
146	`output, err := h.uc.Fetch(ctx, input)`
147	`if err != nil {`
148	`switch {`
149	`case errors.Is(err, entity.ErrNotFound):`
150	`log.Error().Err(err).Msg("uc.FetchLink: not found")`
151	`return fiber.NewError(fiber.StatusNotFound, "not found")`
152	`default:`
153	`log.Error().Err(err).Msg("uc.FetchLink: internal error")`
154	`return fiber.NewError(fiber.StatusInternalServerError, "internal error")`
155	`}`
156	`}`
157
158	`return c.Redirect(output.URL, fiber.StatusFound)`
159	`}`

21	`func run(ctx context.Context, cl configLoader, ar appRunner) error {`
22	`c, err := cl.Load(ctx)`
23	`if err != nil {`
24	`log.Error().Err(err).Msg("config.New")`
25	`return err`
26	`}`
27
28	`logger.Init(c.Logger, c.App.Name, c.App.Version)`
29	`log.Info().Msg("App starting...")`
30	`defer log.Info().Msg("App stopped")`
31
32	`sentry.Init(c.Sentry, c.App.Name, c.App.Version, c.App.Env)`
33	`defer sentry.Close()`
34
35	`otel.Init(ctx, c.Otel, c.App.Name, c.App.Version)`
36	`defer otel.Close()`
37
38	`err = ar.Run(ctx, c)`
39	`if err != nil {`
40	`log.Error().Err(err).Msg("app.Run")`
41	`}`
42	`return err`
43	`}`

45	`func main() {`
46	`ctx, cancel := context.WithCancel(context.Background())`
47	`defer cancel()`
48
49	`if err := run(ctx, cl, ar); err != nil {`
50	`panic(err)`
51	`}`
52	`}`

84	`func (m MockconfigLoader) Load(ctx context.Context) (config.Config, error) {`
85	`m.ctrl.T.Helper()`
86	`ret := m.ctrl.Call(m, "Load", ctx)`
87	`ret0, _ := ret[0].(*config.Config)`
88	`ret1, _ := ret[1].(error)`
89	`return ret0, ret1`
90	`}`

46	`func (m MockappRunner) Run(ctx context.Context, c config.Config) error {`
47	`m.ctrl.T.Helper()`
48	`ret := m.ctrl.Call(m, "Run", ctx, c)`
49	`ret0, _ := ret[0].(error)`
50	`return ret0`
51	`}`

34	`func NewMockappRunner(ctrl gomock.Controller) MockappRunner {`
35	`mock := &MockappRunner{ctrl: ctrl}`
36	`mock.recorder = &MockappRunnerMockRecorder{mock}`
37	`return mock`
38	`}`

72	`func NewMockconfigLoader(ctrl gomock.Controller) MockconfigLoader {`
73	`mock := &MockconfigLoader{ctrl: ctrl}`
74	`mock.recorder = &MockconfigLoaderMockRecorder{mock}`
75	`return mock`
76	`}`

34	`func (a App) Run(ctx context.Context, c *config.Config) error {`
35	`// init dependencies`
36	`postgres, err := postgresClient.New(ctx, &c.Postgres)`
37	`if err != nil {`
38	`return fmt.Errorf("postgres.New: %w", err)`
39	`}`
40	`defer postgres.Close()`
41
42	`redis, err := redisClient.New(&c.Redis)`
43	`if err != nil {`
44	`return fmt.Errorf("redis.New: %w", err)`
45	`}`
46	`defer redis.Close()`
47
48	`KafkaWriter, err := kafkaWriter.New(&c.KafkaWriter)`
49	`if err != nil {`
50	`return fmt.Errorf("kafkaWriter.New: %w", err)`
51	`}`
52	`defer KafkaWriter.Close()`
53
54	`KafkaReader, err := kafkaReader.New(&c.KafkaReader)`
55	`if err != nil {`
56	`return fmt.Errorf("kafkaReader.New: %w", err)`
57	`}`
58	`defer KafkaReader.Close()`
59
60	`// init adapter`
61	`database := adapterPostgres.New(postgres.Pool)`
62	`cache := adapterRedis.New(redis.Client)`
63	`publisher := adapterKafka.New(KafkaWriter.Writer)`
64
65	`// init usecase`
66	`ucCreateLink := usecaseCreate.New(database, cache, publisher)`
67	`ucFetchLink := usecaseFetch.New(database, cache)`
68
69	`// init controller`
70	`errCh := make(chan error)`
71	`defer close(errCh)`
72
73	`httpServer := http.New(c.HTTP, nil, controllerHTTP.New("/api/shortener", ucCreateLink, ucFetchLink))`
74	`go func() { errCh <- httpServer.Serve(c.HTTP.Port) }()`
75	`defer httpServer.Close()`
76
77	`grpcServer := grpc.New(controllerGRPC.New(ucCreateLink, ucFetchLink))`
78	`go func() { errCh <- grpcServer.Serve(ctx, c.GRPC.Port) }()`
79	`defer grpcServer.Close()`
80
81	`kafkaConsumer := controllerKafka.New(KafkaReader, ucCreateLink)`
82	`go func() { errCh <- kafkaConsumer.Consume(ctx) }()`
83
84	`return a.waiting(errCh)`
85	`}`

21	`func (p *Producer) SendLink(ctx context.Context, l entity.Link) error {`
22	`ctx, span := tracer.Start(ctx, "kafka SendLink")`
23	`defer span.End()`
24
25	`err := p.writer.WriteMessages(ctx, kafka.Message{`
26	`Key: []byte(l.Alias),`
27	`Value: []byte(l.URL),`
28	`})`
29	`if err != nil {`
30	`return fmt.Errorf("p.writer.WriteMessages: %w", err)`
31	`}`
32
33	`return nil`
34	`}`

52	`func (p Postgres) FindLink(ctx context.Context, alias, url string) (entity.Link, error) {`
53	`ctx, span := tracer.Start(ctx, "postgres FindLink")`
54	`defer span.End()`
55
56	`var link entity.Link`
57
58	`dataset := goqu.`
59	`Select("id", "url", "alias", "expired_at").`
60	`From("links")`
61
62	`switch {`
63	`case alias != "" && url != "":`
64	`dataset = dataset.Where(goqu.C("alias").Eq(alias), goqu.C("url").Eq(url))`
65	`case alias != "":`
66	`dataset = dataset.Where(goqu.C("alias").Eq(alias))`
67	`case url != "":`
68	`dataset = dataset.Where(goqu.C("url").Eq(url))`
69	`default:`
70	`return nil, fmt.Errorf("query validation")`
71	`}`
72
73	`sql, _, err := dataset.ToSQL()`
74	`if err != nil {`
75	`return nil, fmt.Errorf("dataset.ToSQL: %w", err)`
76	`}`
77
78	`row := p.pool.QueryRow(ctx, sql)`
79	`if err := row.Scan(&link.ID, &link.URL, &link.Alias, &link.ExpiredAt); err != nil {`
80	`if errors.Is(err, pgx.ErrNoRows) {`
81	`return nil, entity.ErrNotFound`
82	`}`
83	`return nil, fmt.Errorf("row.Scan: %w", err)`
84	`}`
85
86	`return &link, nil`
87	`}`

27	`func (p *Postgres) CreateLink(ctx context.Context, link entity.Link) error {`
28	`ctx, span := tracer.Start(ctx, "postgres CreateLink")`
29	`defer span.End()`
30
31	`dataset := goqu.Insert("links").Rows(goqu.Record{`
32	`"id": link.ID,`
33	`"url": link.URL,`
34	`"alias": link.Alias,`
35	`"updated_at": time.Now(),`
36	`"expired_at": link.ExpiredAt,`
37	`})`
38
39	`sql, _, err := dataset.ToSQL()`
40	`if err != nil {`
41	`return fmt.Errorf("dataset.ToSQL: %w", err)`
42	`}`
43
44	`_, err = p.pool.Exec(ctx, sql)`
45	`if err != nil {`
46	`return fmt.Errorf("r.pool.Exec: %w", err)`
47	`}`
48
49	`return nil`
50	`}`

21	`func New(p pgxpool.Pool) Postgres {`
22	`return &Postgres{`
23	`pool: p,`
24	`}`
25	`}`

43	`func (r Redis) GetLink(ctx context.Context, alias string) (entity.Link, error) {`
44	`ctx, span := tracer.Start(ctx, "redis GetLink")`
45	`defer span.End()`
46
47	`var link entity.Link`
48
49	`data, err := r.client.Get(ctx, alias).Bytes()`
50	`if err != nil {`
51	`if errors.Is(err, redis.Nil) {`
52	`return nil, entity.ErrNotFound`
53	`}`
54
55	`return nil, fmt.Errorf("r.client.Get: %w", err)`
56	`}`
57
58	`err = json.Unmarshal(data, &link)`
59	`if err != nil {`
60	`return nil, fmt.Errorf("json.Unmarshal: %w", err)`
61	`}`
62
63	`return &link, nil`
64	`}`

26	`func (r *Redis) PutLink(ctx context.Context, link entity.Link) error {`
27	`ctx, span := tracer.Start(ctx, "redis PutLink")`
28	`defer span.End()`
29
30	`data, err := json.Marshal(link)`
31	`if err != nil {`
32	`return fmt.Errorf("json.Marshal: %w", err)`
33	`}`
34
35	`err = r.client.Set(ctx, link.Alias, data, ttl).Err()`
36	`if err != nil {`
37	`return fmt.Errorf("r.client.Set: %w", err)`
38	`}`
39
40	`return nil`
41	`}`

68	`func (h HandlerFetchLink) FetchLink(ctx context.Context, req pb.FetchLinkRequest) (*pb.FetchLinkResponse, error) {`
69	`ctx, span := tracer.Start(ctx, "grpc/v1 FetchLink")`
70	`defer span.End()`
71
72	`input := dto.FetchLinkInput{Alias: req.GetAlias()}`
73	`if err := input.Validate(); err != nil {`
74	`log.Error().Err(err).Msg("uc.FetchLink: validate error")`
75	`return nil, fmt.Errorf("validation error")`
76	`}`
77
78	`output, err := h.uc.Fetch(ctx, input)`
79	`if err != nil {`
80	`switch {`
81	`case errors.Is(err, entity.ErrNotFound):`
82	`log.Error().Err(err).Msg("uc.FetchLink: not found")`
83	`return nil, fmt.Errorf("not found")`
84	`default:`
85	`log.Error().Err(err).Msg("uc.FetchLink: internal error")`
86	`return nil, fmt.Errorf("internal error")`
87	`}`
88	`}`
89
90	`return &pb.FetchLinkResponse{`
91	`Url: output.URL,`
92	`Alias: output.Alias,`
93	`ExpiredAt: timestamppb.New(output.ExpiredAt),`
94	`}, nil`
95	`}`

28	`func (h HandlerCreateLink) CreateLink(ctx context.Context, req pb.CreateLinkRequest) (*pb.CreateLinkResponse, error) {`
29	`ctx, span := tracer.Start(ctx, "grpc/v1 CreateLink")`
30	`defer span.End()`
31
32	`input := dto.CreateLinkInput{URL: req.GetUrl()}`
33	`if err := input.Validate(); err != nil {`
34	`log.Error().Err(err).Msg("uc.CreateLink: validate error")`
35	`return nil, fmt.Errorf("validation error")`
36	`}`
37
38	`output, err := h.uc.Create(ctx, input)`
39	`if err != nil {`
40	`switch {`
41	`case errors.Is(err, entity.ErrAlreadyExist):`
42	`return &pb.CreateLinkResponse{`
43	`Url: input.URL,`
44	`Alias: output.Alias,`
45	`ExpiredAt: timestamppb.New(output.ExpiredAt),`
46	`}, nil`
47	`default:`
48	`log.Error().Err(err).Msg("uc.CreateLink: internal error")`
49	`return nil, fmt.Errorf("internal error")`
50	`}`
51	`}`
52
53	`return &pb.CreateLinkResponse{`
54	`Url: input.URL,`
55	`Alias: output.Alias,`
56	`ExpiredAt: timestamppb.New(output.ExpiredAt),`
57	`}, nil`
58	`}`

19	`func New(ucCreate create.Usecase, ucFetch fetch.Usecase) *Controller {`
20	`return &Controller{`
21	`createHandler: NewHandlerCreateLink(ucCreate),`
22	`fetchHandler: NewHandlerFetchLink(ucFetch),`
23	`}`
24	`}`

38	`func (h HandlerCreateLink) Handler(c fiber.Ctx) error {`
39	`ctx, span := tracer.Start(c.Context(), "http/v1 CreateLink")`
40	`defer span.End()`
41
42	`var input dto.CreateLinkInput`
43	`if err := c.BodyParser(&input); err != nil {`
44	`log.Error().Err(err).Msg("c.BodyParser")`
45	`return fiber.NewError(fiber.StatusBadRequest, "invalid json")`
46	`}`
47
48	`if err := input.Validate(); err != nil {`
49	`log.Error().Err(err).Msg("uc.CreateLink: validation error")`
50	`return fiber.NewError(fiber.StatusBadRequest, "validation error")`
51	`}`
52
53	`output, err := h.uc.Create(ctx, input)`
54	`if err != nil {`
55	`switch {`
56	`case errors.Is(err, entity.ErrAlreadyExist):`
57	`return c.Status(fiber.StatusFound).JSON(output)`
58	`default:`
59	`log.Error().Err(err).Msg("uc.CreateLink: internal error")`
60	`return fiber.NewError(fiber.StatusInternalServerError, "internal error")`
61	`}`
62	`}`
63
64	`return c.Status(fiber.StatusCreated).JSON(output)`
65	`}`

20	`func (c Controller) Register(app fiber.App) {`
21	`r := app.Group(c.prefix)`
22	`r.Post("/link", NewHandlerCreateLink(c.ucCreate).Handler)`
23	`r.Get("/link/:alias", NewHandlerFetchLink(c.ucFetch).Handler)`
24	`r.Get("/link/:alias/redirect", NewHandlerRedirect(c.ucFetch).Handler)`
25	`}`

22	`func (c *Consumer) Consume(ctx context.Context) error {`
23	`log.Info().Msg("Kafka consumer started")`
24	`for {`
25	`select {`
26	`case <-ctx.Done():`
27	`return nil`
28	`default:`
29	`m, err := c.kafka.FetchMessage(ctx)`
30	`if err != nil {`
31	`log.Error().Err(err).Msg("c.kafka.FetchMessage")`
32	`continue`
33	`}`
34
35	`var input dto.CreateLinkInput`
36	`err = json.Unmarshal(m.Value, &input)`
37	`if err != nil {`
38	`log.Error().Err(err).Msg("json.Unmarshal")`
39	`continue`
40	`}`
41
42	`output, err := c.uc.Create(ctx, input)`
43	`if err != nil {`
44	`log.Error().Err(err).Msg("uc.CreateLink")`
45	`continue`
46	`}`
47	`log.Info().Msg("Link created: " + output.Str())`
48
49	`if err = c.kafka.CommitMessages(ctx, m); err != nil {`
50	`log.Error().Err(err).Msg("c.kafka.CommitMessages")`
51	`continue`
52	`}`
53	`}`
54	`}`
55	`}`

45	`func (m *MockkafkaReader) CommitMessages(ctx context.Context, msgs ...kafka.Message) error {`
46	`m.ctrl.T.Helper()`
47	`varargs := []any{ctx}`
48	`for _, a := range msgs {`
49	`varargs = append(varargs, a)`
50	`}`
51	`ret := m.ctrl.Call(m, "CommitMessages", varargs...)`
52	`ret0, _ := ret[0].(error)`
53	`return ret0`
54	`}`

64	`func (m *MockkafkaReader) FetchMessage(ctx context.Context) (kafka.Message, error) {`
65	`m.ctrl.T.Helper()`
66	`ret := m.ctrl.Call(m, "FetchMessage", ctx)`
67	`ret0, _ := ret[0].(kafka.Message)`
68	`ret1, _ := ret[1].(error)`
69	`return ret0, ret1`
70	`}`

33	`func NewMockkafkaReader(ctrl gomock.Controller) MockkafkaReader {`
34	`mock := &MockkafkaReader{ctrl: ctrl}`
35	`mock.recorder = &MockkafkaReaderMockRecorder{mock}`
36	`return mock`
37	`}`

57	`func (mr MockkafkaReaderMockRecorder) CommitMessages(ctx any, msgs ...any) gomock.Call {`
58	`mr.mock.ctrl.T.Helper()`
59	`varargs := append([]any{ctx}, msgs...)`
60	`return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitMessages", reflect.TypeOf((*MockkafkaReader)(nil).CommitMessages), varargs...)`
61	`}`

31	`func (o CreateLinkOutput) Load(l entity.Link) CreateLinkOutput {`
32	`o.URL = l.URL`
33	`o.Alias = l.Alias`
34	`o.ExpiredAt = l.ExpiredAt`
35
36	`return o`
37	`}`

26	`func (o FetchLinkOutput) Load(l *entity.Link) FetchLinkOutput {`
27	`o.URL = l.URL`
28	`o.Alias = l.Alias`
29	`o.ExpiredAt = l.ExpiredAt`
30
31	`return o`
32	`}`

17	`func (i *CreateLinkInput) Validate() error {`
18	`if i.URL == "" {`
19	`return entity.ErrInputValidation`
20	`}`
21
22	`return nil`
23	`}`

13	`func (i FetchLinkInput) Validate() error {`
14	`if len(i.Alias) < 2 {`
15	`return entity.ErrInputValidation`
16	`}`
17	`return nil`
18	`}`

39	`func (o CreateLinkOutput) Str() string {`
40	`b, err := json.Marshal(o)`
41	`if err != nil {`
42	`log.Error().Err(err).Msg("dto.Str: json.Marshal")`
43	`return fmt.Sprintf("%v", o)`
44	`}`
45	`return string(b)`
46	`}`

28	`func (u *Usecase) Create(ctx context.Context, input dto.CreateLinkInput) (dto.CreateLinkOutput, error) {`
29	`ctx, span := tracer.Start(ctx, "usecase CreateLink")`
30	`defer span.End()`
31
32	`var (`
33	`id = uuid.New()`
34	`alias = base64.RawURLEncoding.EncodeToString(id[:])`
35	`output dto.CreateLinkOutput`
36	`)`
37
38	`link := entity.Link{`
39	`ID: id,`
40	`URL: input.URL,`
41	`Alias: alias,`
42	`ExpiredAt: time.Now().Add(linkTTL),`
43	`}`
44
45	`err := u.database.CreateLink(ctx, link)`
46	`if err != nil {`
47	`return output, fmt.Errorf("u.database.CreateLink: %w", err)`
48	`}`
49
50	`err = u.cache.PutLink(ctx, link)`
51	`if err != nil {`
52	`return output, fmt.Errorf("u.cache.PutLink: %w", err)`
53	`}`
54
55	`err = u.publisher.SendLink(ctx, link)`
56	`if err != nil {`
57	`return output, fmt.Errorf("u.broker.SendLink: %w", err)`
58	`}`
59
60	`return output.Load(link), nil`
61	`}`

46	`func (m *Mockdatabase) CreateLink(arg0 context.Context, arg1 entity.Link) error {`
47	`m.ctrl.T.Helper()`
48	`ret := m.ctrl.Call(m, "CreateLink", arg0, arg1)`
49	`ret0, _ := ret[0].(error)`
50	`return ret0`
51	`}`