17579762087

Committed 09 Sep 2025 10:30AM UTC coverage: 85.54% (+1.1%) from 84.469%

Build # 17579762087

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2453 from Permify/fix-postgres-schemaReader-test

test(internal/storage/postgres): refactor test setup and imports

Run Details

4 of 4 new or added lines in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

9264 of 10830 relevant lines covered (85.54%)

202.77 hits per line

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

93.02

/internal/storage/postgres/bundleReader.go

package postgres

import (
        "context"
        "errors"
        "log/slog"

        "github.com/jackc/pgx/v5"

        "github.com/Masterminds/squirrel"
        "go.opentelemetry.io/otel/codes"
        "google.golang.org/protobuf/encoding/protojson"

        "github.com/Permify/permify/internal"
        "github.com/Permify/permify/internal/storage/postgres/utils"
        db "github.com/Permify/permify/pkg/database/postgres"
        base "github.com/Permify/permify/pkg/pb/base/v1"
)

type BundleReader struct {
        database  *db.Postgres
        txOptions pgx.TxOptions
}

func NewBundleReader(database *db.Postgres) *BundleReader {
        return &BundleReader{
                database:  database,
                txOptions: pgx.TxOptions{IsoLevel: pgx.ReadCommitted, AccessMode: pgx.ReadWrite},
        }
}

func (b *BundleReader) Read(ctx context.Context, tenantID, name string) (bundle *base.DataBundle, err error) {
        ctx, span := internal.Tracer.Start(ctx, "bundle-reader.read-bundle")
        defer span.End()

        slog.DebugContext(ctx, "reading bundle", slog.Any("tenant_id", tenantID), slog.Any("name", name))

        builder := b.database.Builder.Select("payload").From(BundlesTable).Where(squirrel.Eq{"name": name, "tenant_id": tenantID})

        var query string
        var args []interface{}

        query, args, err = builder.ToSql()
        if err != nil {
                return nil, utils.HandleError(ctx, span, err, base.ErrorCode_ERROR_CODE_SQL_BUILDER)
        }

        slog.DebugContext(ctx, "executing sql query", slog.Any("query", query), slog.Any("arguments", args))

        row := b.database.ReadPool.QueryRow(ctx, query, args...)

        var jsonData string
        err = row.Scan(&jsonData)
        if err != nil {
                if errors.Is(err, pgx.ErrNoRows) {
                        return nil, errors.New(base.ErrorCode_ERROR_CODE_BUNDLE_NOT_FOUND.String())
                }
                return nil, utils.HandleError(ctx, span, err, base.ErrorCode_ERROR_CODE_SCAN)
        }

        bundle = &base.DataBundle{}
        err = protojson.Unmarshal([]byte(jsonData), bundle)
        if err != nil {
                span.RecordError(err)
                span.SetStatus(codes.Error, err.Error())

                slog.ErrorContext(ctx, "failed to convert the value to bundle", slog.Any("error", err))

                return nil, errors.New(base.ErrorCode_ERROR_CODE_INVALID_ARGUMENT.String())
        }

        return bundle, err
}

1	package postgres
2
3	import (
4	"context"
5	"errors"
6	"log/slog"
7
8	"github.com/jackc/pgx/v5"
9
10	"github.com/Masterminds/squirrel"
11	"go.opentelemetry.io/otel/codes"
12	"google.golang.org/protobuf/encoding/protojson"
13
14	"github.com/Permify/permify/internal"
15	"github.com/Permify/permify/internal/storage/postgres/utils"
16	db "github.com/Permify/permify/pkg/database/postgres"
17	base "github.com/Permify/permify/pkg/pb/base/v1"
18	)
19
20	type BundleReader struct {
21	database *db.Postgres
22	txOptions pgx.TxOptions
23	}
24
25	func NewBundleReader(database db.Postgres) BundleReader {	35✔
26	return &BundleReader{	35✔
27	database: database,	35✔
28	txOptions: pgx.TxOptions{IsoLevel: pgx.ReadCommitted, AccessMode: pgx.ReadWrite},	35✔
29	}	35✔
30	}	35✔
31
32	func (b BundleReader) Read(ctx context.Context, tenantID, name string) (bundle base.DataBundle, err error) {	9✔
33	ctx, span := internal.Tracer.Start(ctx, "bundle-reader.read-bundle")	9✔
34	defer span.End()	9✔
35		9✔
36	slog.DebugContext(ctx, "reading bundle", slog.Any("tenant_id", tenantID), slog.Any("name", name))	9✔
37		9✔
38	builder := b.database.Builder.Select("payload").From(BundlesTable).Where(squirrel.Eq{"name": name, "tenant_id": tenantID})	9✔
39		9✔
40	var query string	9✔
41	var args []interface{}	9✔
42		9✔
43	query, args, err = builder.ToSql()	9✔
44	if err != nil {	9✔
45	return nil, utils.HandleError(ctx, span, err, base.ErrorCode_ERROR_CODE_SQL_BUILDER)	×
46	}	×
47
48	slog.DebugContext(ctx, "executing sql query", slog.Any("query", query), slog.Any("arguments", args))	9✔
49		9✔
50	row := b.database.ReadPool.QueryRow(ctx, query, args...)	9✔
51		9✔
52	var jsonData string	9✔
53	err = row.Scan(&jsonData)	9✔
54	if err != nil {	11✔
55	if errors.Is(err, pgx.ErrNoRows) {	4✔
56	return nil, errors.New(base.ErrorCode_ERROR_CODE_BUNDLE_NOT_FOUND.String())	2✔
57	}	2✔
UNCOV 58	return nil, utils.HandleError(ctx, span, err, base.ErrorCode_ERROR_CODE_SCAN)	×
59	}
60
61	bundle = &base.DataBundle{}	7✔
62	err = protojson.Unmarshal([]byte(jsonData), bundle)	7✔
63	if err != nil {	8✔
64	span.RecordError(err)	1✔
65	span.SetStatus(codes.Error, err.Error())	1✔
66		1✔
67	slog.ErrorContext(ctx, "failed to convert the value to bundle", slog.Any("error", err))	1✔
68		1✔
69	return nil, errors.New(base.ErrorCode_ERROR_CODE_INVALID_ARGUMENT.String())	1✔
70	}	1✔
71
72	return bundle, err	6✔
73	}

Permify / permify / 17579762087

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

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