Hackaton: Add more unit tests, take 2 (#101473)

* login/social/socialimpl: add assertions for usage stats, support bundle and oauthinfo methods

* accesscontrol/acimpl: add tests for GetRoleByName

* anonymous/sortopts: add tests for Sorter

* cloudmigration/gmsclient: add basic test cases for all methods

* shorturls/shorturlimpl: add more edge test cases

* tag/tagimpl: add test to cover duplicate tag kv and nil pairs

* updatechecker: add test cases for module
This commit is contained in:
Matheus Macabu
2025-03-03 13:12:13 +01:00
committed by GitHub
parent d1b20c652d
commit b110754c9a
10 changed files with 887 additions and 5 deletions
@@ -32,7 +32,7 @@ func NewGMSClient(cfg *setting.Cfg, httpClient *http.Client) (Client, error) {
type gmsClientImpl struct {
cfg *setting.Cfg
log *log.ConcreteLogger
log log.Logger
httpClient *http.Client
getStatusMux sync.Mutex
@@ -1,13 +1,20 @@
package gmsclient
import (
"context"
"fmt"
"net/http"
"net/http/httptest"
"runtime"
"testing"
"time"
"github.com/grafana/grafana/pkg/infra/log/logtest"
"github.com/grafana/grafana/pkg/services/cloudmigration"
"github.com/grafana/grafana/pkg/setting"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"golang.org/x/sync/errgroup"
)
func Test_buildURL(t *testing.T) {
@@ -129,3 +136,474 @@ func Test_handleGMSErrors(t *testing.T) {
require.ErrorIs(t, resError, tc.expectedError)
}
}
func Test_ValidateKey(t *testing.T) {
t.Parallel()
t.Run("when the key is valid, it returns no error", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusOK)
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSValidateKeyTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
err := client.ValidateKey(ctx, session)
require.NoError(t, err)
})
t.Run("when the key invalidated for any reason, it returns a token validation failure", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusBadRequest)
_, _ = w.Write([]byte(`{"message": "instance is unreachable"}`)) // could be any other error that is unmapped.
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSValidateKeyTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
err := client.ValidateKey(ctx, session)
require.Error(t, err)
})
}
func Test_StartSnapshot(t *testing.T) {
t.Parallel()
t.Run("when the session is valid, a snapshot result is returned", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
expectedSnapshot := &cloudmigration.StartSnapshotResponse{
SnapshotID: "uuid",
MaxItemsPerPartition: 1024,
Algo: "nacl",
EncryptionKey: []uint8{0x66, 0x6f, 0x6f, 0xa}, // foo
Metadata: []uint8{0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xa}, // metadata
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{
"snapshotID": "uuid",
"maxItemsPerPartition": 1024,
"algo": "nacl",
"encryptionKey": "Zm9vCg==",
"metadata": "bWV0YWRhdGEK"
}`))
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSStartSnapshotTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
resp, err := client.StartSnapshot(ctx, session)
require.NoError(t, err)
require.NotNil(t, resp)
require.EqualValues(t, expectedSnapshot, resp)
})
t.Run("when there is an error in the upstream, it logs and returns the error", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusInternalServerError)
_, _ = w.Write([]byte(`{"message": "internal server error"}`))
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSStartSnapshotTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
resp, err := client.StartSnapshot(ctx, session)
require.Error(t, err)
require.Nil(t, resp)
require.Equal(t, 1, logger.ErrorLogs.Calls)
})
}
func Test_GetSnapshotStatus(t *testing.T) {
t.Parallel()
t.Run("it queries the snapshot status and returns it", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
snapshot := cloudmigration.CloudMigrationSnapshot{
UID: "snapshot-uuid",
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodGet, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{
"state": "PROCESSING",
"results": []
}`))
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSGetSnapshotStatusTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
g, gctx := errgroup.WithContext(ctx)
for range runtime.NumCPU() * 2 { // run a couple of concurrent requests to check for race condition.
g.Go(func() error {
resp, err := client.GetSnapshotStatus(gctx, session, snapshot, 0)
require.NotNil(t, resp)
return err
})
}
require.NoError(t, g.Wait())
require.NotEmpty(t, client.getStatusLastQueried)
})
t.Run("when there is an error in the upstream, it logs and returns the error", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
snapshot := cloudmigration.CloudMigrationSnapshot{
UID: "snapshot-uuid",
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodGet, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusInternalServerError)
_, _ = w.Write([]byte(`{"message": "internal server error"}`))
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSGetSnapshotStatusTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
resp, err := client.GetSnapshotStatus(ctx, session, snapshot, 0)
require.Error(t, err)
require.Nil(t, resp)
require.Equal(t, 1, logger.ErrorLogs.Calls)
})
}
func Test_CreatePresignedUploadUrl(t *testing.T) {
t.Parallel()
t.Run("when the snapshot and session are valid, it returns a presigned url string", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
snapshot := cloudmigration.CloudMigrationSnapshot{
UID: "snapshot-uuid",
}
expectedURL := "http://example.com"
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(`{"uploadUrl": "` + expectedURL + `"}`))
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSCreateUploadUrlTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
url, err := client.CreatePresignedUploadUrl(ctx, session, snapshot)
require.NoError(t, err)
require.Equal(t, expectedURL, url)
})
t.Run("when there is an error in the upstream, it logs and returns the error", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
snapshot := cloudmigration.CloudMigrationSnapshot{
UID: "snapshot-uuid",
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusInternalServerError)
_, _ = w.Write([]byte(`{"message": "internal server error"}`))
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSCreateUploadUrlTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
url, err := client.CreatePresignedUploadUrl(ctx, session, snapshot)
require.Error(t, err)
require.Empty(t, url)
require.Equal(t, 1, logger.ErrorLogs.Calls)
})
}
func Test_ReportEvent(t *testing.T) {
t.Parallel()
t.Run("when the session data is valid, it does not log an error", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
event := EventRequestDTO{
LocalID: "local-id",
Event: EventDoneUploadingSnapshot,
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
auth := r.Header.Get("Authorization")
require.Equal(t, fmt.Sprintf("Bearer %d:%s", session.StackID, session.AuthToken), auth)
w.WriteHeader(http.StatusNoContent)
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSReportEventTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
client.ReportEvent(ctx, session, event)
require.Zero(t, logger.DebugLogs.Calls)
require.Zero(t, logger.WarnLogs.Calls)
require.Zero(t, logger.InfoLogs.Calls)
require.Zero(t, logger.ErrorLogs.Calls)
})
t.Run("when the session is missing required data, it returns without doing anything", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
event := EventRequestDTO{
Event: EventDoneUploadingSnapshot,
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.True(t, false) // This will never be called, but if it does, it will cause the test to fail.
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSReportEventTimeout: 0, // this won't be called.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
client.ReportEvent(ctx, cloudmigration.CloudMigrationSession{}, event)
require.Zero(t, logger.DebugLogs.Calls)
require.Zero(t, logger.WarnLogs.Calls)
require.Zero(t, logger.InfoLogs.Calls)
require.Zero(t, logger.ErrorLogs.Calls)
})
t.Run("when the upstream server is down, it logs the error", func(t *testing.T) {
t.Parallel()
ctx := context.Background()
session := cloudmigration.CloudMigrationSession{
StackID: 1234,
AuthToken: "auth-tok",
ClusterSlug: "cluster-slug",
}
event := EventRequestDTO{
LocalID: "local-id",
Event: EventDoneUploadingSnapshot,
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
require.Equal(t, http.MethodPost, r.Method)
w.WriteHeader(http.StatusInternalServerError)
_, _ = w.Write([]byte(`{"message": "internal server error"}`))
}))
t.Cleanup(server.Close)
cfg := &setting.Cfg{
CloudMigration: setting.CloudMigrationSettings{
GMSDomain: server.URL,
GMSReportEventTimeout: time.Hour, // arbitrary, it just can't be 0.
},
}
logger := &logtest.Fake{}
client := gmsClientImpl{cfg: cfg, log: logger, httpClient: http.DefaultClient}
client.ReportEvent(ctx, session, event)
require.Zero(t, logger.DebugLogs.Calls)
require.Zero(t, logger.WarnLogs.Calls)
require.Zero(t, logger.InfoLogs.Calls)
require.Equal(t, 2, logger.ErrorLogs.Calls)
})
}