Andres Martinez Gotor
429 lines
13 KiB
Go
429 lines
13 KiB
Go
package checkscheduler
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"math/rand/v2"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/grafana/grafana-app-sdk/logging"
|
|
"github.com/grafana/grafana-app-sdk/resource"
|
|
advisorv0alpha1 "github.com/grafana/grafana/apps/advisor/pkg/apis/advisor/v0alpha1"
|
|
"github.com/grafana/grafana/apps/advisor/pkg/app/checks"
|
|
"github.com/stretchr/testify/assert"
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
)
|
|
|
|
func TestRunner_Run(t *testing.T) {
|
|
t.Run("does not crash when error on list", func(t *testing.T) {
|
|
mockClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
return nil, errors.New("list error")
|
|
},
|
|
createFunc: func(ctx context.Context, id resource.Identifier, obj resource.Object, opts resource.CreateOptions) (resource.Object, error) {
|
|
return &advisorv0alpha1.Check{}, nil
|
|
},
|
|
}
|
|
|
|
mockTypesClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
return &advisorv0alpha1.CheckTypeList{Items: []advisorv0alpha1.CheckType{}}, nil
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
client: mockClient,
|
|
typesClient: mockTypesClient,
|
|
log: &logging.NoOpLogger{},
|
|
evaluationInterval: 1 * time.Hour,
|
|
}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
err := runner.Run(ctx)
|
|
assert.ErrorAs(t, err, &context.Canceled)
|
|
})
|
|
}
|
|
|
|
func TestRunner_checkLastCreated_ErrorOnList(t *testing.T) {
|
|
mockClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
return nil, errors.New("list error")
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
client: mockClient,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
|
|
lastCreated, err := runner.checkLastCreated(context.Background(), &logging.NoOpLogger{})
|
|
assert.Error(t, err)
|
|
assert.True(t, lastCreated.IsZero())
|
|
}
|
|
|
|
func TestRunner_checkLastCreated_UnprocessedCheck(t *testing.T) {
|
|
patchOperation := resource.PatchOperation{}
|
|
identifier := resource.Identifier{}
|
|
|
|
mockClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
return &advisorv0alpha1.CheckList{
|
|
Items: []advisorv0alpha1.Check{
|
|
{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "check-1",
|
|
},
|
|
},
|
|
},
|
|
}, nil
|
|
},
|
|
patchFunc: func(ctx context.Context, id resource.Identifier, patch resource.PatchRequest, options resource.PatchOptions, into resource.Object) error {
|
|
patchOperation = patch.Operations[0]
|
|
identifier = id
|
|
return nil
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
client: mockClient,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
|
|
lastCreated, err := runner.checkLastCreated(context.Background(), &logging.NoOpLogger{})
|
|
assert.NoError(t, err)
|
|
assert.True(t, lastCreated.IsZero())
|
|
assert.Equal(t, "check-1", identifier.Name)
|
|
assert.Equal(t, "/metadata/annotations", patchOperation.Path)
|
|
expectedAnnotations := map[string]string{
|
|
checks.StatusAnnotation: "error",
|
|
}
|
|
assert.Equal(t, expectedAnnotations, patchOperation.Value)
|
|
}
|
|
|
|
func TestRunner_checkLastCreated_PaginatedResponse(t *testing.T) {
|
|
// Create checks with different creation times
|
|
past := time.Now().Add(-1 * time.Hour)
|
|
now := time.Now()
|
|
|
|
mockClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
if options.Continue == "" {
|
|
// First page - return oldest and middle checks with continue token
|
|
return &advisorv0alpha1.CheckList{
|
|
ListMeta: metav1.ListMeta{
|
|
Continue: "continue-token-123",
|
|
},
|
|
Items: []advisorv0alpha1.Check{
|
|
{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "check-1",
|
|
CreationTimestamp: metav1.NewTime(past),
|
|
Annotations: map[string]string{
|
|
checks.StatusAnnotation: "completed",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "check-2",
|
|
CreationTimestamp: metav1.NewTime(past),
|
|
Annotations: map[string]string{
|
|
checks.StatusAnnotation: "completed",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, nil
|
|
}
|
|
// Second page - verify continue token is passed and return newest check
|
|
assert.Equal(t, "continue-token-123", options.Continue)
|
|
return &advisorv0alpha1.CheckList{
|
|
Items: []advisorv0alpha1.Check{
|
|
{
|
|
ObjectMeta: metav1.ObjectMeta{
|
|
Name: "check-3",
|
|
CreationTimestamp: metav1.NewTime(now),
|
|
Annotations: map[string]string{
|
|
checks.StatusAnnotation: "completed",
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}, nil
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
client: mockClient,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
|
|
lastCreated, err := runner.checkLastCreated(context.Background(), &logging.NoOpLogger{})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, now.Truncate(time.Second), lastCreated.Truncate(time.Second))
|
|
}
|
|
|
|
func TestRunner_createChecks_ErrorOnCreate(t *testing.T) {
|
|
mockCheckService := &MockCheckService{checks: []checks.Check{&mockCheck{id: "check-1"}}}
|
|
|
|
mockClient := &MockClient{
|
|
createFunc: func(ctx context.Context, id resource.Identifier, obj resource.Object, opts resource.CreateOptions) (resource.Object, error) {
|
|
return nil, errors.New("create error")
|
|
},
|
|
}
|
|
|
|
mockTypesClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
checkType := &advisorv0alpha1.CheckType{}
|
|
checkType.Spec.Name = "check-1"
|
|
return &advisorv0alpha1.CheckTypeList{
|
|
Items: []advisorv0alpha1.CheckType{*checkType},
|
|
}, nil
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
checkRegistry: mockCheckService,
|
|
client: mockClient,
|
|
typesClient: mockTypesClient,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
|
|
err := runner.createChecks(context.Background(), &logging.NoOpLogger{})
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestRunner_createChecks_Success(t *testing.T) {
|
|
mockCheckService := &MockCheckService{checks: []checks.Check{&mockCheck{id: "check-1"}}}
|
|
|
|
mockClient := &MockClient{
|
|
createFunc: func(ctx context.Context, id resource.Identifier, obj resource.Object, opts resource.CreateOptions) (resource.Object, error) {
|
|
return &advisorv0alpha1.Check{}, nil
|
|
},
|
|
}
|
|
|
|
mockTypesClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
checkType := &advisorv0alpha1.CheckType{}
|
|
checkType.Spec.Name = "check-1"
|
|
return &advisorv0alpha1.CheckTypeList{
|
|
Items: []advisorv0alpha1.CheckType{*checkType},
|
|
}, nil
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
checkRegistry: mockCheckService,
|
|
client: mockClient,
|
|
typesClient: mockTypesClient,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
|
|
err := runner.createChecks(context.Background(), &logging.NoOpLogger{})
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestRunner_cleanupChecks_ErrorOnList(t *testing.T) {
|
|
mockClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
return nil, errors.New("list error")
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
client: mockClient,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
|
|
err := runner.cleanupChecks(context.Background(), &logging.NoOpLogger{})
|
|
assert.Error(t, err)
|
|
}
|
|
|
|
func TestRunner_cleanupChecks_WithinMax(t *testing.T) {
|
|
mockClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
return &advisorv0alpha1.CheckList{
|
|
Items: []advisorv0alpha1.Check{{}, {}},
|
|
}, nil
|
|
},
|
|
deleteFunc: func(ctx context.Context, identifier resource.Identifier, options resource.DeleteOptions) error {
|
|
return fmt.Errorf("shouldn't be called")
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
client: mockClient,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
|
|
err := runner.cleanupChecks(context.Background(), &logging.NoOpLogger{})
|
|
assert.NoError(t, err)
|
|
}
|
|
|
|
func TestRunner_cleanupChecks_ErrorOnDelete(t *testing.T) {
|
|
mockClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
items := make([]advisorv0alpha1.Check, 0, defaultMaxHistory+1)
|
|
for i := 0; i < defaultMaxHistory+1; i++ {
|
|
item := advisorv0alpha1.Check{}
|
|
item.SetLabels(map[string]string{
|
|
checks.TypeLabel: "mock",
|
|
})
|
|
items = append(items, item)
|
|
}
|
|
return &advisorv0alpha1.CheckList{
|
|
Items: items,
|
|
}, nil
|
|
},
|
|
deleteFunc: func(ctx context.Context, identifier resource.Identifier, options resource.DeleteOptions) error {
|
|
return errors.New("delete error")
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
client: mockClient,
|
|
maxHistory: defaultMaxHistory,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
err := runner.cleanupChecks(context.Background(), &logging.NoOpLogger{})
|
|
assert.ErrorContains(t, err, "delete error")
|
|
}
|
|
|
|
func TestRunner_cleanupChecks_Success(t *testing.T) {
|
|
itemsDeleted := []string{}
|
|
items := make([]advisorv0alpha1.Check, 0, defaultMaxHistory+1)
|
|
for i := 0; i < defaultMaxHistory+1; i++ {
|
|
item := advisorv0alpha1.Check{}
|
|
item.SetName(fmt.Sprintf("check-%d", i))
|
|
item.SetLabels(map[string]string{
|
|
checks.TypeLabel: "mock",
|
|
})
|
|
item.SetCreationTimestamp(metav1.NewTime(time.Time{}.Add(time.Duration(i) * time.Hour)))
|
|
items = append(items, item)
|
|
}
|
|
// shuffle the items to ensure the oldest are deleted
|
|
rand.Shuffle(len(items), func(i, j int) { items[i], items[j] = items[j], items[i] })
|
|
|
|
mockClient := &MockClient{
|
|
listFunc: func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
return &advisorv0alpha1.CheckList{
|
|
Items: items,
|
|
}, nil
|
|
},
|
|
deleteFunc: func(ctx context.Context, identifier resource.Identifier, options resource.DeleteOptions) error {
|
|
itemsDeleted = append(itemsDeleted, identifier.Name)
|
|
return nil
|
|
},
|
|
}
|
|
|
|
runner := &Runner{
|
|
client: mockClient,
|
|
maxHistory: defaultMaxHistory,
|
|
log: &logging.NoOpLogger{},
|
|
}
|
|
err := runner.cleanupChecks(context.Background(), &logging.NoOpLogger{})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, []string{"check-0"}, itemsDeleted)
|
|
}
|
|
|
|
func Test_getEvaluationInterval(t *testing.T) {
|
|
t.Run("default", func(t *testing.T) {
|
|
interval, err := getEvaluationInterval(map[string]string{})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 7*24*time.Hour, interval)
|
|
})
|
|
|
|
t.Run("invalid", func(t *testing.T) {
|
|
interval, err := getEvaluationInterval(map[string]string{"evaluation_interval": "invalid"})
|
|
assert.Error(t, err)
|
|
assert.Zero(t, interval)
|
|
})
|
|
|
|
t.Run("custom", func(t *testing.T) {
|
|
interval, err := getEvaluationInterval(map[string]string{"evaluation_interval": "1h"})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, time.Hour, interval)
|
|
})
|
|
}
|
|
|
|
func Test_getMaxHistory(t *testing.T) {
|
|
t.Run("default", func(t *testing.T) {
|
|
history, err := getMaxHistory(map[string]string{})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 10, history)
|
|
})
|
|
|
|
t.Run("invalid", func(t *testing.T) {
|
|
history, err := getMaxHistory(map[string]string{"max_history": "invalid"})
|
|
assert.Error(t, err)
|
|
assert.Zero(t, history)
|
|
})
|
|
|
|
t.Run("custom", func(t *testing.T) {
|
|
history, err := getMaxHistory(map[string]string{"max_history": "5"})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 5, history)
|
|
})
|
|
}
|
|
|
|
func Test_getNextSendInterval(t *testing.T) {
|
|
lastCreated := time.Now().Add(-7 * 24 * time.Hour)
|
|
evaluationInterval := 7 * 24 * time.Hour
|
|
nextSendInterval := getNextSendInterval(lastCreated, evaluationInterval)
|
|
// The next send interval should be in < 1 hour
|
|
assert.True(t, nextSendInterval < time.Hour)
|
|
// Calculate the next send interval again and it should be different
|
|
nextSendInterval2 := getNextSendInterval(lastCreated, evaluationInterval)
|
|
assert.NotEqual(t, nextSendInterval, nextSendInterval2)
|
|
}
|
|
|
|
type MockClient struct {
|
|
resource.Client
|
|
listFunc func(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error)
|
|
createFunc func(ctx context.Context, identifier resource.Identifier, obj resource.Object, options resource.CreateOptions) (resource.Object, error)
|
|
deleteFunc func(ctx context.Context, identifier resource.Identifier, options resource.DeleteOptions) error
|
|
patchFunc func(ctx context.Context, identifier resource.Identifier, patch resource.PatchRequest, options resource.PatchOptions, into resource.Object) error
|
|
}
|
|
|
|
func (m *MockClient) List(ctx context.Context, namespace string, options resource.ListOptions) (resource.ListObject, error) {
|
|
return m.listFunc(ctx, namespace, options)
|
|
}
|
|
|
|
func (m *MockClient) Create(ctx context.Context, identifier resource.Identifier, obj resource.Object, options resource.CreateOptions) (resource.Object, error) {
|
|
return m.createFunc(ctx, identifier, obj, options)
|
|
}
|
|
|
|
func (m *MockClient) Delete(ctx context.Context, identifier resource.Identifier, options resource.DeleteOptions) error {
|
|
return m.deleteFunc(ctx, identifier, options)
|
|
}
|
|
|
|
func (m *MockClient) PatchInto(ctx context.Context, identifier resource.Identifier, patch resource.PatchRequest, options resource.PatchOptions, into resource.Object) error {
|
|
return m.patchFunc(ctx, identifier, patch, options, into)
|
|
}
|
|
|
|
type MockCheckService struct {
|
|
checks []checks.Check
|
|
}
|
|
|
|
func (m *MockCheckService) Checks() []checks.Check {
|
|
return m.checks
|
|
}
|
|
|
|
type mockCheck struct {
|
|
checks.Check
|
|
|
|
id string
|
|
steps []checks.Step
|
|
}
|
|
|
|
func (m *mockCheck) ID() string {
|
|
return m.id
|
|
}
|
|
|
|
func (m *mockCheck) Steps() []checks.Step {
|
|
return m.steps
|
|
}
|