mirror of https://github.com/grafana/grafana
Ryan McKinley
2 years ago
parent
c1798320d2
commit
8f44e1a349
@ -1 +0,0 @@ |
||||
package auth |
||||
@ -0,0 +1,176 @@ |
||||
package identity |
||||
|
||||
import "fmt" |
||||
|
||||
var _ Requester = &StaticRequester{} |
||||
|
||||
// StaticRequester is helpful for tests
|
||||
// This is mostly copied from:
|
||||
// https://github.com/grafana/grafana/blob/v11.0.0/pkg/services/user/identity.go#L16
|
||||
type StaticRequester struct { |
||||
Namespace Namespace |
||||
UserID int64 |
||||
UserUID string |
||||
OrgID int64 |
||||
OrgName string |
||||
OrgRole RoleType |
||||
Login string |
||||
Name string |
||||
DisplayName string |
||||
Email string |
||||
EmailVerified bool |
||||
AuthID string |
||||
AuthenticatedBy string |
||||
IsGrafanaAdmin bool |
||||
IsAnonymous bool |
||||
IsDisabled bool |
||||
// Permissions grouped by orgID and actions
|
||||
Permissions map[int64]map[string][]string |
||||
IDToken string |
||||
CacheKey string |
||||
} |
||||
|
||||
func (u *StaticRequester) HasRole(role RoleType) bool { |
||||
if u.IsGrafanaAdmin { |
||||
return true |
||||
} |
||||
|
||||
return u.OrgRole.Includes(role) |
||||
} |
||||
|
||||
// GetIsGrafanaAdmin returns true if the user is a server admin
|
||||
func (u *StaticRequester) GetIsGrafanaAdmin() bool { |
||||
return u.IsGrafanaAdmin |
||||
} |
||||
|
||||
// GetLogin returns the login of the active entity
|
||||
// Can be empty if the user is anonymous
|
||||
func (u *StaticRequester) GetLogin() string { |
||||
return u.Login |
||||
} |
||||
|
||||
// GetOrgID returns the ID of the active organization
|
||||
func (u *StaticRequester) GetOrgID() int64 { |
||||
return u.OrgID |
||||
} |
||||
|
||||
// DEPRECATED: GetOrgName returns the name of the active organization
|
||||
// Retrieve the organization name from the organization service instead of using this method.
|
||||
func (u *StaticRequester) GetOrgName() string { |
||||
return u.OrgName |
||||
} |
||||
|
||||
// GetPermissions returns the permissions of the active entity
|
||||
func (u *StaticRequester) GetPermissions() map[string][]string { |
||||
if u.Permissions == nil { |
||||
return make(map[string][]string) |
||||
} |
||||
|
||||
if u.Permissions[u.GetOrgID()] == nil { |
||||
return make(map[string][]string) |
||||
} |
||||
|
||||
return u.Permissions[u.GetOrgID()] |
||||
} |
||||
|
||||
// GetGlobalPermissions returns the permissions of the active entity that are available across all organizations
|
||||
func (u *StaticRequester) GetGlobalPermissions() map[string][]string { |
||||
if u.Permissions == nil { |
||||
return make(map[string][]string) |
||||
} |
||||
|
||||
const globalOrgID = 0 |
||||
|
||||
if u.Permissions[globalOrgID] == nil { |
||||
return make(map[string][]string) |
||||
} |
||||
|
||||
return u.Permissions[globalOrgID] |
||||
} |
||||
|
||||
// DEPRECATED: GetTeams returns the teams the entity is a member of
|
||||
// Retrieve the teams from the team service instead of using this method.
|
||||
func (u *StaticRequester) GetTeams() []int64 { |
||||
return []int64{} // Not implemented
|
||||
} |
||||
|
||||
// GetOrgRole returns the role of the active entity in the active organization
|
||||
func (u *StaticRequester) GetOrgRole() RoleType { |
||||
return u.OrgRole |
||||
} |
||||
|
||||
// HasUniqueId returns true if the entity has a unique id
|
||||
func (u *StaticRequester) HasUniqueId() bool { |
||||
return u.UserID > 0 |
||||
} |
||||
|
||||
// GetID returns namespaced id for the entity
|
||||
func (u *StaticRequester) GetID() NamespaceID { |
||||
return NewNamespaceIDString(u.Namespace, fmt.Sprintf("%d", u.UserID)) |
||||
} |
||||
|
||||
// GetUID returns namespaced uid for the entity
|
||||
func (u *StaticRequester) GetUID() NamespaceID { |
||||
return NewNamespaceIDString(u.Namespace, u.UserUID) |
||||
} |
||||
|
||||
// GetNamespacedID returns the namespace and ID of the active entity
|
||||
// The namespace is one of the constants defined in pkg/apimachinery/identity
|
||||
func (u *StaticRequester) GetNamespacedID() (Namespace, string) { |
||||
return u.Namespace, fmt.Sprintf("%d", u.UserID) |
||||
} |
||||
|
||||
func (u *StaticRequester) GetAuthID() string { |
||||
return u.AuthID |
||||
} |
||||
|
||||
func (u *StaticRequester) GetAuthenticatedBy() string { |
||||
return u.AuthenticatedBy |
||||
} |
||||
|
||||
func (u *StaticRequester) IsAuthenticatedBy(providers ...string) bool { |
||||
for _, p := range providers { |
||||
if u.AuthenticatedBy == p { |
||||
return true |
||||
} |
||||
} |
||||
return false |
||||
} |
||||
|
||||
// FIXME: remove this method once all services are using an interface
|
||||
func (u *StaticRequester) IsNil() bool { |
||||
return u == nil |
||||
} |
||||
|
||||
// GetEmail returns the email of the active entity
|
||||
// Can be empty.
|
||||
func (u *StaticRequester) GetEmail() string { |
||||
return u.Email |
||||
} |
||||
|
||||
func (u *StaticRequester) IsEmailVerified() bool { |
||||
return u.EmailVerified |
||||
} |
||||
|
||||
func (u *StaticRequester) GetCacheKey() string { |
||||
return u.CacheKey |
||||
} |
||||
|
||||
// GetDisplayName returns the display name of the active entity
|
||||
// The display name is the name if it is set, otherwise the login or email
|
||||
func (u *StaticRequester) GetDisplayName() string { |
||||
if u.DisplayName != "" { |
||||
return u.DisplayName |
||||
} |
||||
if u.Name != "" { |
||||
return u.Name |
||||
} |
||||
if u.Login != "" { |
||||
return u.Login |
||||
} |
||||
return u.Email |
||||
} |
||||
|
||||
func (u *StaticRequester) GetIDToken() string { |
||||
return u.IDToken |
||||
} |
||||
@ -1,222 +0,0 @@ |
||||
package sqlstash |
||||
|
||||
import ( |
||||
"context" |
||||
"database/sql" |
||||
"embed" |
||||
"errors" |
||||
"fmt" |
||||
"strings" |
||||
"text/template" |
||||
|
||||
"github.com/grafana/grafana/pkg/services/store/entity/db" |
||||
"github.com/grafana/grafana/pkg/services/store/entity/sqlstash/sqltemplate" |
||||
) |
||||
|
||||
// Templates setup.
|
||||
var ( |
||||
//go:embed data/*.sql
|
||||
sqlTemplatesFS embed.FS |
||||
|
||||
// all templates
|
||||
helpers = template.FuncMap{ |
||||
"listSep": helperListSep, |
||||
"join": helperJoin, |
||||
} |
||||
sqlTemplates = template.Must(template.New("sql").Funcs(helpers).ParseFS(sqlTemplatesFS, `data/*.sql`)) |
||||
) |
||||
|
||||
func mustTemplate(filename string) *template.Template { |
||||
if t := sqlTemplates.Lookup(filename); t != nil { |
||||
return t |
||||
} |
||||
panic(fmt.Sprintf("template file not found: %s", filename)) |
||||
} |
||||
|
||||
// Templates.
|
||||
var ( |
||||
sqlResourceVersionGet = mustTemplate("rv_get.sql") |
||||
sqlResourceVersionInc = mustTemplate("rv_inc.sql") |
||||
sqlResourceVersionInsert = mustTemplate("rv_insert.sql") |
||||
sqlResourceVersionLock = mustTemplate("rv_lock.sql") |
||||
|
||||
sqlResourceInsert = mustTemplate("resource_insert.sql") |
||||
sqlResourceGet = mustTemplate("resource_get.sql") |
||||
) |
||||
|
||||
// TxOptions.
|
||||
var ( |
||||
ReadCommitted = &sql.TxOptions{ |
||||
Isolation: sql.LevelReadCommitted, |
||||
} |
||||
ReadCommittedRO = &sql.TxOptions{ |
||||
Isolation: sql.LevelReadCommitted, |
||||
ReadOnly: true, |
||||
} |
||||
) |
||||
|
||||
// SQLError is an error returned by the database, which includes additionally
|
||||
// debugging information about what was sent to the database.
|
||||
type SQLError struct { |
||||
Err error |
||||
CallType string // either Query, QueryRow or Exec
|
||||
TemplateName string |
||||
Query string |
||||
RawQuery string |
||||
ScanDest []any |
||||
|
||||
// potentially regulated information is not exported and only directly
|
||||
// available for local testing and local debugging purposes, making sure it
|
||||
// is never marshaled to JSON or any other serialization.
|
||||
|
||||
arguments []any |
||||
} |
||||
|
||||
func (e SQLError) Unwrap() error { |
||||
return e.Err |
||||
} |
||||
|
||||
func (e SQLError) Error() string { |
||||
return fmt.Sprintf("%s: %s with %d input arguments and %d output "+ |
||||
"destination arguments: %v", e.TemplateName, e.CallType, |
||||
len(e.arguments), len(e.ScanDest), e.Err) |
||||
} |
||||
|
||||
//------------------------------------------------------------------------
|
||||
// Resource Version table support
|
||||
//------------------------------------------------------------------------
|
||||
|
||||
type returnsResourceVersion struct { |
||||
ResourceVersion int64 |
||||
} |
||||
|
||||
func (r *returnsResourceVersion) Results() (*returnsResourceVersion, error) { |
||||
return r, nil |
||||
} |
||||
|
||||
type sqlResourceVersionGetRequest struct { |
||||
*sqltemplate.SQLTemplate |
||||
Group string |
||||
Resource string |
||||
*returnsResourceVersion |
||||
} |
||||
|
||||
func (r sqlResourceVersionGetRequest) Validate() error { |
||||
return nil // TODO
|
||||
} |
||||
|
||||
type sqlResourceVersionLockRequest struct { |
||||
*sqltemplate.SQLTemplate |
||||
Group string |
||||
Resource string |
||||
*returnsResourceVersion |
||||
} |
||||
|
||||
func (r sqlResourceVersionLockRequest) Validate() error { |
||||
return nil // TODO
|
||||
} |
||||
|
||||
type sqlResourceVersionIncRequest struct { |
||||
*sqltemplate.SQLTemplate |
||||
Group string |
||||
Resource string |
||||
ResourceVersion int64 |
||||
} |
||||
|
||||
func (r sqlResourceVersionIncRequest) Validate() error { |
||||
return nil // TODO
|
||||
} |
||||
|
||||
type sqlResourceVersionInsertRequest struct { |
||||
*sqltemplate.SQLTemplate |
||||
Group string |
||||
Resource string |
||||
} |
||||
|
||||
func (r sqlResourceVersionInsertRequest) Validate() error { |
||||
return nil // TODO
|
||||
} |
||||
|
||||
// resourceVersionAtomicInc atomically increases the version of a kind within a
|
||||
// transaction.
|
||||
func resourceVersionAtomicInc(ctx context.Context, x db.ContextExecer, d sqltemplate.Dialect, group, resource string) (newVersion int64, err error) { |
||||
// 1. Lock the kind and get the latest version
|
||||
lockReq := sqlResourceVersionLockRequest{ |
||||
SQLTemplate: sqltemplate.New(d), |
||||
Group: group, |
||||
Resource: resource, |
||||
returnsResourceVersion: new(returnsResourceVersion), |
||||
} |
||||
kindv, err := queryRow(ctx, x, sqlResourceVersionLock, lockReq) |
||||
|
||||
// if there wasn't a row associated with the given kind, we create one with
|
||||
// version 1
|
||||
if errors.Is(err, sql.ErrNoRows) { |
||||
// NOTE: there is a marginal chance that we race with another writer
|
||||
// trying to create the same row. This is only possible when onboarding
|
||||
// a new (Group, Resource) to the cell, which should be very unlikely,
|
||||
// and the workaround is simply retrying. The alternative would be to
|
||||
// use INSERT ... ON CONFLICT DO UPDATE ..., but that creates a
|
||||
// requirement for support in Dialect only for this marginal case, and
|
||||
// we would rather keep Dialect as small as possible. Another
|
||||
// alternative is to simply check if the INSERT returns a DUPLICATE KEY
|
||||
// error and then retry the original SELECT, but that also adds some
|
||||
// complexity to the code. That would be preferrable to changing
|
||||
// Dialect, though. The current alternative, just retrying, seems to be
|
||||
// enough for now.
|
||||
insReq := sqlResourceVersionInsertRequest{ |
||||
SQLTemplate: sqltemplate.New(d), |
||||
Group: group, |
||||
Resource: resource, |
||||
} |
||||
if _, err = exec(ctx, x, sqlResourceVersionInsert, insReq); err != nil { |
||||
return 0, fmt.Errorf("insert into kind_version: %w", err) |
||||
} |
||||
|
||||
return 1, nil |
||||
} |
||||
|
||||
if err != nil { |
||||
return 0, fmt.Errorf("lock kind: %w", err) |
||||
} |
||||
|
||||
incReq := sqlResourceVersionIncRequest{ |
||||
SQLTemplate: sqltemplate.New(d), |
||||
Group: group, |
||||
Resource: resource, |
||||
ResourceVersion: kindv.ResourceVersion, |
||||
} |
||||
if _, err = exec(ctx, x, sqlResourceVersionInc, incReq); err != nil { |
||||
return 0, fmt.Errorf("increase kind version: %w", err) |
||||
} |
||||
|
||||
return kindv.ResourceVersion + 1, nil |
||||
} |
||||
|
||||
// Template helpers.
|
||||
|
||||
// helperListSep is a helper that helps writing simpler loops in SQL templates.
|
||||
// Example usage:
|
||||
//
|
||||
// {{ $comma := listSep ", " }}
|
||||
// {{ range .Values }}
|
||||
// {{/* here we put "-" on each end to remove extra white space */}}
|
||||
// {{- call $comma -}}
|
||||
// {{ .Value }}
|
||||
// {{ end }}
|
||||
func helperListSep(sep string) func() string { |
||||
var addSep bool |
||||
|
||||
return func() string { |
||||
if addSep { |
||||
return sep |
||||
} |
||||
addSep = true |
||||
|
||||
return "" |
||||
} |
||||
} |
||||
|
||||
func helperJoin(sep string, elems ...string) string { |
||||
return strings.Join(elems, sep) |
||||
} |
||||
@ -1,25 +0,0 @@ |
||||
{ |
||||
"apiVersion": "playlist.grafana.app/v0alpha1", |
||||
"kind": "Playlist", |
||||
"metadata": { |
||||
"name": "fdgsv37qslr0ga", |
||||
"namespace": "default", |
||||
"annotations": { |
||||
"grafana.app/originName": "elsewhere", |
||||
"grafana.app/originPath": "path/to/item", |
||||
"grafana.app/originTimestamp": "2024-02-02T00:00:00Z" |
||||
}, |
||||
"creationTimestamp": "2024-03-03T00:00:00Z", |
||||
"uid": "8tGrXJgGbFI0" |
||||
}, |
||||
"spec": { |
||||
"title": "hello", |
||||
"interval": "5m", |
||||
"items": [ |
||||
{ |
||||
"type": "dashboard_by_uid", |
||||
"value": "vmie2cmWz" |
||||
} |
||||
] |
||||
} |
||||
} |
||||
@ -1,503 +0,0 @@ |
||||
package sqlstash |
||||
|
||||
import ( |
||||
"database/sql" |
||||
"database/sql/driver" |
||||
"errors" |
||||
"fmt" |
||||
"io" |
||||
"regexp" |
||||
"strings" |
||||
"testing" |
||||
"text/template" |
||||
|
||||
sqlmock "github.com/DATA-DOG/go-sqlmock" |
||||
"github.com/stretchr/testify/require" |
||||
|
||||
"github.com/grafana/grafana/pkg/services/store/entity/db" |
||||
"github.com/grafana/grafana/pkg/services/store/entity/db/dbimpl" |
||||
"github.com/grafana/grafana/pkg/services/store/entity/sqlstash/sqltemplate" |
||||
sqltemplateMocks "github.com/grafana/grafana/pkg/services/store/entity/sqlstash/sqltemplate/mocks" |
||||
"github.com/grafana/grafana/pkg/util/testutil" |
||||
) |
||||
|
||||
// newMockDBNopSQL returns a db.DB and a sqlmock.Sqlmock that doesn't validates
|
||||
// SQL. This is only meant to be used to test wrapping utilities exec, query and
|
||||
// queryRow, where the actual SQL is not relevant to the unit tests, but rather
|
||||
// how the possible derived error conditions handled.
|
||||
func newMockDBNopSQL(t *testing.T) (db.DB, sqlmock.Sqlmock) { |
||||
t.Helper() |
||||
|
||||
db, mock, err := sqlmock.New( |
||||
sqlmock.MonitorPingsOption(true), |
||||
sqlmock.QueryMatcherOption(sqlmock.QueryMatcherFunc( |
||||
func(expectedSQL, actualSQL string) error { |
||||
return nil |
||||
}, |
||||
)), |
||||
) |
||||
|
||||
return newUnitTestDB(t, db, mock, err) |
||||
} |
||||
|
||||
// newMockDBMatchWords returns a db.DB and a sqlmock.Sqlmock that will match SQL
|
||||
// by splitting the expected SQL string into words, and then try to find all of
|
||||
// them in the actual SQL, in the given order, case insensitively. Prepend a
|
||||
// word with a `!` to say that word should not be found.
|
||||
func newMockDBMatchWords(t *testing.T) (db.DB, sqlmock.Sqlmock) { |
||||
t.Helper() |
||||
|
||||
db, mock, err := sqlmock.New( |
||||
sqlmock.MonitorPingsOption(true), |
||||
sqlmock.QueryMatcherOption( |
||||
sqlmock.QueryMatcherFunc(func(expectedSQL, actualSQL string) error { |
||||
actualSQL = strings.ToLower(sqltemplate.FormatSQL(actualSQL)) |
||||
expectedSQL = strings.ToLower(expectedSQL) |
||||
|
||||
var offset int |
||||
for _, vv := range mockDBMatchWordsRE.FindAllStringSubmatch(expectedSQL, -1) { |
||||
v := vv[1] |
||||
|
||||
var shouldNotMatch bool |
||||
if v != "" && v[0] == '!' { |
||||
v = v[1:] |
||||
shouldNotMatch = true |
||||
} |
||||
if v == "" { |
||||
return fmt.Errorf("invalid expected word %q in %q", v, |
||||
expectedSQL) |
||||
} |
||||
|
||||
reWord, err := regexp.Compile(`\b` + regexp.QuoteMeta(v) + `\b`) |
||||
if err != nil { |
||||
return fmt.Errorf("compile word %q from expected SQL: %s", v, |
||||
expectedSQL) |
||||
} |
||||
|
||||
if shouldNotMatch { |
||||
if reWord.MatchString(actualSQL[offset:]) { |
||||
return fmt.Errorf("actual SQL fragent should not cont"+ |
||||
"ain %q but it does\n\tFragment: %s\n\tFull SQL: %s", |
||||
v, actualSQL[offset:], actualSQL) |
||||
} |
||||
} else { |
||||
loc := reWord.FindStringIndex(actualSQL[offset:]) |
||||
if len(loc) == 0 { |
||||
return fmt.Errorf("actual SQL fragment should contain "+ |
||||
"%q but it doesn't\n\tFragment: %s\n\tFull SQL: %s", |
||||
v, actualSQL[offset:], actualSQL) |
||||
} |
||||
offset = loc[1] // advance the offset
|
||||
} |
||||
} |
||||
|
||||
return nil |
||||
}, |
||||
), |
||||
), |
||||
) |
||||
|
||||
return newUnitTestDB(t, db, mock, err) |
||||
} |
||||
|
||||
var mockDBMatchWordsRE = regexp.MustCompile(`(?:\W|\A)(!?\w+)\b`) |
||||
|
||||
func newUnitTestDB(t *testing.T, db *sql.DB, mock sqlmock.Sqlmock, err error) (db.DB, sqlmock.Sqlmock) { |
||||
t.Helper() |
||||
|
||||
require.NoError(t, err) |
||||
|
||||
return dbimpl.NewDB(db, "sqlmock"), mock |
||||
} |
||||
|
||||
// mockResults aids in testing code paths with queries returning large number of
|
||||
// values, like those returning *entity.Entity. This is because we want to
|
||||
// emulate returning the same row columns and row values the same as a real
|
||||
// database would do. This utility the same template SQL that is expected to be
|
||||
// used to help populate all the expected fields.
|
||||
// fileds
|
||||
type mockResults[T any] struct { |
||||
t *testing.T |
||||
tmpl *template.Template |
||||
data sqltemplate.WithResults[T] |
||||
rows *sqlmock.Rows |
||||
} |
||||
|
||||
// newMockResults returns a new *mockResults. If you want to emulate a call
|
||||
// returning zero rows, then immediately call the Row method afterward.
|
||||
func newMockResults[T any](t *testing.T, mock sqlmock.Sqlmock, tmpl *template.Template, data sqltemplate.WithResults[T]) *mockResults[T] { |
||||
t.Helper() |
||||
|
||||
data.Reset() |
||||
err := tmpl.Execute(io.Discard, data) |
||||
require.NoError(t, err) |
||||
rows := mock.NewRows(data.GetColNames()) |
||||
|
||||
return &mockResults[T]{ |
||||
t: t, |
||||
tmpl: tmpl, |
||||
data: data, |
||||
rows: rows, |
||||
} |
||||
} |
||||
|
||||
// AddCurrentData uses the values contained in the `data` argument used during
|
||||
// creation to populate a new expected row. It will access `data` with pointers,
|
||||
// so you should replace the internal values of `data` with freshly allocated
|
||||
// results to return different rows.
|
||||
func (r *mockResults[T]) AddCurrentData() *mockResults[T] { |
||||
r.t.Helper() |
||||
|
||||
r.data.Reset() |
||||
err := r.tmpl.Execute(io.Discard, r.data) |
||||
require.NoError(r.t, err) |
||||
|
||||
d := r.data.GetScanDest() |
||||
dv := make([]driver.Value, len(d)) |
||||
for i, v := range d { |
||||
dv[i] = v |
||||
} |
||||
r.rows.AddRow(dv...) |
||||
|
||||
return r |
||||
} |
||||
|
||||
// Rows returns the *sqlmock.Rows object built.
|
||||
func (r *mockResults[T]) Rows() *sqlmock.Rows { |
||||
return r.rows |
||||
} |
||||
|
||||
func TestPtrOr(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
p := ptrOr[*int]() |
||||
require.NotNil(t, p) |
||||
require.Zero(t, *p) |
||||
|
||||
p = ptrOr[*int](nil, nil, nil, nil, nil, nil) |
||||
require.NotNil(t, p) |
||||
require.Zero(t, *p) |
||||
|
||||
v := 42 |
||||
v2 := 5 |
||||
p = ptrOr(nil, nil, nil, &v, nil, &v2, nil, nil) |
||||
require.NotNil(t, p) |
||||
require.Equal(t, v, *p) |
||||
|
||||
p = ptrOr(nil, nil, nil, &v) |
||||
require.NotNil(t, p) |
||||
require.Equal(t, v, *p) |
||||
} |
||||
|
||||
func TestSliceOr(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
p := sliceOr[[]int]() |
||||
require.NotNil(t, p) |
||||
require.Len(t, p, 0) |
||||
|
||||
p = sliceOr[[]int](nil, nil, nil, nil) |
||||
require.NotNil(t, p) |
||||
require.Len(t, p, 0) |
||||
|
||||
p = sliceOr([]int{}, []int{}, []int{}, []int{}) |
||||
require.NotNil(t, p) |
||||
require.Len(t, p, 0) |
||||
|
||||
v := []int{1, 2} |
||||
p = sliceOr([]int{}, nil, []int{}, v, nil, []int{}, []int{10}, nil) |
||||
require.NotNil(t, p) |
||||
require.Equal(t, v, p) |
||||
|
||||
p = sliceOr([]int{}, nil, []int{}, v) |
||||
require.NotNil(t, p) |
||||
require.Equal(t, v, p) |
||||
} |
||||
|
||||
func TestMapOr(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
p := mapOr[map[string]int]() |
||||
require.NotNil(t, p) |
||||
require.Len(t, p, 0) |
||||
|
||||
p = mapOr(nil, map[string]int(nil), nil, map[string]int{}, nil) |
||||
require.NotNil(t, p) |
||||
require.Len(t, p, 0) |
||||
|
||||
v := map[string]int{"a": 0, "b": 1} |
||||
v2 := map[string]int{"c": 2, "d": 3} |
||||
|
||||
p = mapOr(nil, map[string]int(nil), v, v2, nil, map[string]int{}, nil) |
||||
require.NotNil(t, p) |
||||
require.Equal(t, v, p) |
||||
|
||||
p = mapOr(nil, map[string]int(nil), v) |
||||
require.NotNil(t, p) |
||||
require.Equal(t, v, p) |
||||
} |
||||
|
||||
var ( |
||||
validTestTmpl = template.Must(template.New("test").Parse("nothing special")) |
||||
invalidTestTmpl = template.New("no definition should fail to exec") |
||||
errTest = errors.New("because of reasons") |
||||
) |
||||
|
||||
// expectRows is a testing helper to keep mocks in sync when adding rows to a
|
||||
// mocked SQL result. This is a helper to test `query` and `queryRow`.
|
||||
type expectRows[T any] struct { |
||||
*sqlmock.Rows |
||||
ExpectedResults []T |
||||
|
||||
req *sqltemplateMocks.WithResults[T] |
||||
} |
||||
|
||||
func newReturnsRow[T any](dbmock sqlmock.Sqlmock, req *sqltemplateMocks.WithResults[T]) *expectRows[T] { |
||||
return &expectRows[T]{ |
||||
Rows: dbmock.NewRows(nil), |
||||
req: req, |
||||
} |
||||
} |
||||
|
||||
// Add adds a new value that should be returned by the `query` or `queryRow`
|
||||
// operation.
|
||||
func (r *expectRows[T]) Add(value T, err error) *expectRows[T] { |
||||
r.req.EXPECT().GetScanDest().Return(nil).Once() |
||||
r.req.EXPECT().Results().Return(value, err).Once() |
||||
r.Rows.AddRow() |
||||
r.ExpectedResults = append(r.ExpectedResults, value) |
||||
|
||||
return r |
||||
} |
||||
|
||||
func TestQueryRow(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
t.Run("happy path", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
ctx := testutil.NewDefaultTestContext(t) |
||||
req := sqltemplateMocks.NewWithResults[int64](t) |
||||
db, dbmock := newMockDBNopSQL(t) |
||||
rows := newReturnsRow(dbmock, req) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().Validate().Return(nil).Once() |
||||
req.EXPECT().GetArgs().Return(nil).Once() |
||||
rows.Add(1, nil) |
||||
dbmock.ExpectQuery("").WillReturnRows(rows.Rows) |
||||
|
||||
// execute and assert
|
||||
res, err := queryRow(ctx, db, validTestTmpl, req) |
||||
require.NoError(t, err) |
||||
require.Equal(t, rows.ExpectedResults[0], res) |
||||
}) |
||||
|
||||
t.Run("invalid request", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
ctx := testutil.NewDefaultTestContext(t) |
||||
req := sqltemplateMocks.NewWithResults[int64](t) |
||||
db, _ := newMockDBNopSQL(t) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().Validate().Return(errTest).Once() |
||||
|
||||
// execute and assert
|
||||
res, err := queryRow(ctx, db, invalidTestTmpl, req) |
||||
require.Zero(t, res) |
||||
require.Error(t, err) |
||||
require.ErrorContains(t, err, "invalid request") |
||||
}) |
||||
|
||||
t.Run("error executing template", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
ctx := testutil.NewDefaultTestContext(t) |
||||
req := sqltemplateMocks.NewWithResults[int64](t) |
||||
db, _ := newMockDBNopSQL(t) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().Validate().Return(nil).Once() |
||||
|
||||
// execute and assert
|
||||
res, err := queryRow(ctx, db, invalidTestTmpl, req) |
||||
require.Zero(t, res) |
||||
require.Error(t, err) |
||||
require.ErrorContains(t, err, "execute template") |
||||
}) |
||||
|
||||
t.Run("error executing query", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
ctx := testutil.NewDefaultTestContext(t) |
||||
req := sqltemplateMocks.NewWithResults[int64](t) |
||||
db, dbmock := newMockDBNopSQL(t) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().Validate().Return(nil).Once() |
||||
req.EXPECT().GetArgs().Return(nil) |
||||
req.EXPECT().GetScanDest().Return(nil).Maybe() |
||||
dbmock.ExpectQuery("").WillReturnError(errTest) |
||||
|
||||
// execute and assert
|
||||
res, err := queryRow(ctx, db, validTestTmpl, req) |
||||
require.Zero(t, res) |
||||
require.Error(t, err) |
||||
require.ErrorAs(t, err, new(SQLError)) |
||||
}) |
||||
} |
||||
|
||||
// scannerFunc is an adapter for the `scanner` interface.
|
||||
type scannerFunc func(dest ...any) error |
||||
|
||||
func (f scannerFunc) Scan(dest ...any) error { |
||||
return f(dest...) |
||||
} |
||||
|
||||
func TestScanRow(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
const value int64 = 1 |
||||
|
||||
t.Run("happy path", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
req := sqltemplateMocks.NewWithResults[int64](t) |
||||
sc := scannerFunc(func(dest ...any) error { |
||||
return nil |
||||
}) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().GetScanDest().Return(nil).Once() |
||||
req.EXPECT().Results().Return(value, nil).Once() |
||||
|
||||
// execute and assert
|
||||
res, err := scanRow(sc, req) |
||||
require.NoError(t, err) |
||||
require.Equal(t, value, res) |
||||
}) |
||||
|
||||
t.Run("scan error", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
req := sqltemplateMocks.NewWithResults[int64](t) |
||||
sc := scannerFunc(func(dest ...any) error { |
||||
return errTest |
||||
}) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().GetScanDest().Return(nil).Once() |
||||
|
||||
// execute and assert
|
||||
res, err := scanRow(sc, req) |
||||
require.Zero(t, res) |
||||
require.Error(t, err) |
||||
require.ErrorIs(t, err, errTest) |
||||
}) |
||||
|
||||
t.Run("results error", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
req := sqltemplateMocks.NewWithResults[int64](t) |
||||
sc := scannerFunc(func(dest ...any) error { |
||||
return nil |
||||
}) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().GetScanDest().Return(nil).Once() |
||||
req.EXPECT().Results().Return(0, errTest).Once() |
||||
|
||||
// execute and assert
|
||||
res, err := scanRow(sc, req) |
||||
require.Zero(t, res) |
||||
require.Error(t, err) |
||||
require.ErrorIs(t, err, errTest) |
||||
}) |
||||
} |
||||
|
||||
func TestExec(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
t.Run("happy path", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
ctx := testutil.NewDefaultTestContext(t) |
||||
req := sqltemplateMocks.NewSQLTemplateIface(t) |
||||
db, dbmock := newMockDBNopSQL(t) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().Validate().Return(nil).Once() |
||||
req.EXPECT().GetArgs().Return(nil).Once() |
||||
dbmock.ExpectExec("").WillReturnResult(sqlmock.NewResult(0, 0)) |
||||
|
||||
// execute and assert
|
||||
res, err := exec(ctx, db, validTestTmpl, req) |
||||
require.NoError(t, err) |
||||
require.NotNil(t, res) |
||||
}) |
||||
|
||||
t.Run("invalid request", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
ctx := testutil.NewDefaultTestContext(t) |
||||
req := sqltemplateMocks.NewSQLTemplateIface(t) |
||||
db, _ := newMockDBNopSQL(t) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().Validate().Return(errTest).Once() |
||||
|
||||
// execute and assert
|
||||
res, err := exec(ctx, db, invalidTestTmpl, req) |
||||
require.Nil(t, res) |
||||
require.Error(t, err) |
||||
require.ErrorContains(t, err, "invalid request") |
||||
}) |
||||
|
||||
t.Run("error executing template", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
ctx := testutil.NewDefaultTestContext(t) |
||||
req := sqltemplateMocks.NewSQLTemplateIface(t) |
||||
db, _ := newMockDBNopSQL(t) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().Validate().Return(nil).Once() |
||||
|
||||
// execute and assert
|
||||
res, err := exec(ctx, db, invalidTestTmpl, req) |
||||
require.Nil(t, res) |
||||
require.Error(t, err) |
||||
require.ErrorContains(t, err, "execute template") |
||||
}) |
||||
|
||||
t.Run("error executing SQL", func(t *testing.T) { |
||||
t.Parallel() |
||||
|
||||
// test declarations
|
||||
ctx := testutil.NewDefaultTestContext(t) |
||||
req := sqltemplateMocks.NewSQLTemplateIface(t) |
||||
db, dbmock := newMockDBNopSQL(t) |
||||
|
||||
// setup expectations
|
||||
req.EXPECT().Validate().Return(nil).Once() |
||||
req.EXPECT().GetArgs().Return(nil) |
||||
dbmock.ExpectExec("").WillReturnError(errTest) |
||||
|
||||
// execute and assert
|
||||
res, err := exec(ctx, db, validTestTmpl, req) |
||||
require.Nil(t, res) |
||||
require.Error(t, err) |
||||
require.ErrorAs(t, err, new(SQLError)) |
||||
}) |
||||
} |
||||
Loading…
Reference in new issue