1370 lines
34 KiB
Go
1370 lines
34 KiB
Go
package testing
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/influxdata/influxdb/v2"
|
|
"github.com/influxdata/influxdb/v2/mock"
|
|
"github.com/influxdata/influxdb/v2/pkg/testing/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
const (
|
|
idA = "020f755c3c082000"
|
|
idB = "020f755c3c082001"
|
|
idC = "020f755c3c082002"
|
|
idD = "020f755c3c082003"
|
|
)
|
|
|
|
var oldFakeDate = time.Date(2002, 8, 5, 2, 2, 3, 0, time.UTC)
|
|
var fakeDate = time.Date(2006, 5, 4, 1, 2, 3, 0, time.UTC)
|
|
var fakeGenerator = mock.TimeGenerator{FakeValue: fakeDate}
|
|
|
|
var variableCmpOptions = cmp.Options{
|
|
cmp.Comparer(func(x, y []byte) bool {
|
|
return bytes.Equal(x, y)
|
|
}),
|
|
cmp.Transformer("Sort", func(in []*influxdb.Variable) []*influxdb.Variable {
|
|
out := append([]*influxdb.Variable(nil), in...)
|
|
sort.Slice(out, func(i, j int) bool {
|
|
return out[i].ID.String() > out[j].ID.String()
|
|
})
|
|
return out
|
|
}),
|
|
}
|
|
|
|
// VariableFields defines fields for a variable test
|
|
type VariableFields struct {
|
|
Variables []*influxdb.Variable
|
|
IDGenerator influxdb.IDGenerator
|
|
TimeGenerator influxdb.TimeGenerator
|
|
}
|
|
|
|
type VariableSvcOpts struct {
|
|
HTTPValidation bool
|
|
}
|
|
|
|
func WithHTTPValidation() VariableSvcOpts {
|
|
return VariableSvcOpts{
|
|
HTTPValidation: true,
|
|
}
|
|
}
|
|
|
|
// VariableService tests all the service functions.
|
|
func VariableService(
|
|
init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()), t *testing.T, opts ...VariableSvcOpts,
|
|
) {
|
|
tests := []struct {
|
|
name string
|
|
fn func(init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()),
|
|
t *testing.T)
|
|
}{
|
|
{
|
|
name: "CreateVariable",
|
|
fn: CreateVariable,
|
|
},
|
|
{
|
|
name: "TrimWhitespace",
|
|
fn: TrimWhitespace,
|
|
},
|
|
{
|
|
name: "FindVariableByID",
|
|
fn: FindVariableByID,
|
|
},
|
|
{
|
|
name: "FindVariables",
|
|
fn: FindVariables,
|
|
},
|
|
{
|
|
name: "UpdateVariable",
|
|
fn: UpdateVariable,
|
|
},
|
|
{
|
|
name: "ReplaceVariable",
|
|
fn: ReplaceVariable,
|
|
},
|
|
{
|
|
name: "DeleteVariable",
|
|
fn: DeleteVariable,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
if tt.name == "trimwhitespace" && len(opts) > 0 && !opts[0].HTTPValidation || len(opts) == 0 {
|
|
continue
|
|
}
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
tt := tt
|
|
t.Parallel()
|
|
tt.fn(init, t)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TrimWhitespace(init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()), t *testing.T) {
|
|
type args struct {
|
|
variable *influxdb.Variable
|
|
}
|
|
type wants struct {
|
|
err *influxdb.Error
|
|
variables []*influxdb.Variable
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fields VariableFields
|
|
args args
|
|
wants wants
|
|
}{
|
|
{
|
|
// trims white space, but fails when variable name already exists
|
|
name: "trimwhitespace",
|
|
fields: VariableFields{
|
|
IDGenerator: &mock.IDGenerator{
|
|
IDFn: func() influxdb.ID {
|
|
return MustIDBase16(idA)
|
|
},
|
|
},
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
variable: &influxdb.Variable{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: " existing-variable ",
|
|
Selected: []string{"a"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"a"},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Code: influxdb.EConflict,
|
|
Msg: "variable is not unique",
|
|
},
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s, _, done := init(tt.fields, t)
|
|
defer done()
|
|
ctx := context.Background()
|
|
|
|
err := s.CreateVariable(ctx, tt.args.variable)
|
|
influxErrsEqual(t, tt.wants.err, err)
|
|
|
|
variables, err := s.FindVariables(ctx, influxdb.VariableFilter{})
|
|
if err != nil {
|
|
t.Fatalf("failed to retrieve variables: %v", err)
|
|
}
|
|
if diff := cmp.Diff(variables, tt.wants.variables, variableCmpOptions...); diff != "" {
|
|
t.Fatalf("found unexpected variables -got/+want\ndiff %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// CreateVariable tests influxdb.VariableService CreateVariable interface method
|
|
func CreateVariable(init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()), t *testing.T) {
|
|
type args struct {
|
|
variable *influxdb.Variable
|
|
}
|
|
type wants struct {
|
|
err *influxdb.Error
|
|
variables []*influxdb.Variable
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fields VariableFields
|
|
args args
|
|
wants wants
|
|
}{
|
|
{
|
|
name: "basic create with missing id",
|
|
fields: VariableFields{
|
|
IDGenerator: &mock.IDGenerator{
|
|
IDFn: func() influxdb.ID {
|
|
return MustIDBase16(idD)
|
|
},
|
|
},
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(1),
|
|
Name: "already there",
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
variable: &influxdb.Variable{
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "basic variable",
|
|
Selected: []string{"a"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"a"},
|
|
},
|
|
},
|
|
},
|
|
wants: wants{
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(1),
|
|
Name: "already there",
|
|
},
|
|
{
|
|
ID: MustIDBase16(idD),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "basic variable",
|
|
Selected: []string{"a"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"a"},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "creating a variable assigns the variable an id and adds it to the store",
|
|
fields: VariableFields{
|
|
IDGenerator: &mock.IDGenerator{
|
|
IDFn: func() influxdb.ID {
|
|
return MustIDBase16(idA)
|
|
},
|
|
},
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
variable: &influxdb.Variable{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "MY-variable",
|
|
Selected: []string{"a"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"a"},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: nil,
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "MY-variable",
|
|
Selected: []string{"a"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"a"},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "cant create a new variable with a name that exists",
|
|
fields: VariableFields{
|
|
IDGenerator: &mock.IDGenerator{
|
|
IDFn: func() influxdb.ID {
|
|
return MustIDBase16(idA)
|
|
},
|
|
},
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: MustIDBase16(idD),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
variable: &influxdb.Variable{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: MustIDBase16(idD),
|
|
Name: "existing-variable",
|
|
Selected: []string{"a"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"a"},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Code: influxdb.EConflict,
|
|
Msg: "variable is not unique",
|
|
},
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: MustIDBase16(idD),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "variable names should be unique and case-insensitive",
|
|
fields: VariableFields{
|
|
IDGenerator: &mock.IDGenerator{
|
|
IDFn: func() influxdb.ID {
|
|
return MustIDBase16(idA)
|
|
},
|
|
},
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
variable: &influxdb.Variable{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "EXISTING-variable",
|
|
Selected: []string{"a"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"a"},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Code: influxdb.EConflict,
|
|
Msg: "variable is not unique for key ",
|
|
},
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "cant create a new variable when variable name exists with a different type",
|
|
fields: VariableFields{
|
|
IDGenerator: &mock.IDGenerator{
|
|
IDFn: func() influxdb.ID {
|
|
return MustIDBase16(idA)
|
|
},
|
|
},
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
variable: &influxdb.Variable{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"a"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"a"},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Code: influxdb.EConflict,
|
|
Msg: "variable is not unique",
|
|
},
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(3),
|
|
Name: "existing-variable",
|
|
Selected: []string{"b"},
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{"b"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s, _, done := init(tt.fields, t)
|
|
defer done()
|
|
ctx := context.Background()
|
|
|
|
err := s.CreateVariable(ctx, tt.args.variable)
|
|
influxErrsEqual(t, tt.wants.err, err)
|
|
|
|
variables, err := s.FindVariables(ctx, influxdb.VariableFilter{})
|
|
if err != nil {
|
|
t.Fatalf("failed to retrieve variables: %v", err)
|
|
}
|
|
if diff := cmp.Diff(variables, tt.wants.variables, variableCmpOptions...); diff != "" {
|
|
t.Fatalf("found unexpected variables -got/+want\ndiff %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// FindVariableByID tests influxdb.VariableService FindVariableByID interface method
|
|
func FindVariableByID(init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()), t *testing.T) {
|
|
type args struct {
|
|
id influxdb.ID
|
|
}
|
|
type wants struct {
|
|
err *influxdb.Error
|
|
variable *influxdb.Variable
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fields VariableFields
|
|
args args
|
|
wants wants
|
|
}{
|
|
{
|
|
name: "finding a variable that exists by id",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(5),
|
|
Name: "existing-variable-a",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(5),
|
|
Name: "existing-variable-b",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idB),
|
|
},
|
|
wants: wants{
|
|
err: nil,
|
|
variable: &influxdb.Variable{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(5),
|
|
Name: "existing-variable-b",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "finding a non-existent variable",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idA),
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Code: influxdb.ENotFound,
|
|
Op: influxdb.OpFindVariableByID,
|
|
Msg: influxdb.ErrVariableNotFound,
|
|
},
|
|
variable: nil,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s, _, done := init(tt.fields, t)
|
|
defer done()
|
|
ctx := context.Background()
|
|
|
|
variable, err := s.FindVariableByID(ctx, tt.args.id)
|
|
if err != nil {
|
|
if tt.wants.err == nil {
|
|
require.NoError(t, err)
|
|
}
|
|
iErr, ok := err.(*influxdb.Error)
|
|
require.True(t, ok)
|
|
assert.Equal(t, iErr.Code, tt.wants.err.Code)
|
|
assert.Equal(t, strings.HasPrefix(iErr.Error(), tt.wants.err.Error()), true)
|
|
return
|
|
}
|
|
|
|
if diff := cmp.Diff(variable, tt.wants.variable, variableCmpOptions...); diff != "" {
|
|
t.Fatalf("found unexpected variable -got/+want\ndiff %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// FindVariables tests influxdb.variableService FindVariables interface method
|
|
func FindVariables(init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()), t *testing.T) {
|
|
// todo(leodido)
|
|
type args struct {
|
|
// todo(leodido) > use VariableFilter as arg
|
|
orgID *influxdb.ID
|
|
findOpts influxdb.FindOptions
|
|
}
|
|
type wants struct {
|
|
variables []*influxdb.Variable
|
|
err error
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fields VariableFields
|
|
args args
|
|
wants wants
|
|
}{
|
|
{
|
|
name: "find nothing (empty set)",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{},
|
|
},
|
|
args: args{
|
|
findOpts: influxdb.DefaultVariableFindOptions,
|
|
},
|
|
wants: wants{
|
|
variables: []*influxdb.Variable{},
|
|
},
|
|
},
|
|
{
|
|
name: "find all variables",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "a",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "b",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
findOpts: influxdb.DefaultVariableFindOptions,
|
|
},
|
|
wants: wants{
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "a",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "b",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "find variables by wrong org id",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "a",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "b",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
findOpts: influxdb.DefaultVariableFindOptions,
|
|
orgID: idPtr(influxdb.ID(1)),
|
|
},
|
|
wants: wants{
|
|
variables: []*influxdb.Variable{},
|
|
},
|
|
},
|
|
{
|
|
name: "find all variables by org 22",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(1),
|
|
Name: "a",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "b",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idC),
|
|
OrganizationID: influxdb.ID(2),
|
|
Name: "c",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idD),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "d",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
findOpts: influxdb.DefaultVariableFindOptions,
|
|
orgID: idPtr(influxdb.ID(22)),
|
|
},
|
|
wants: wants{
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "b",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idD),
|
|
OrganizationID: influxdb.ID(22),
|
|
Name: "d",
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: fakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s, opPrefix, done := init(tt.fields, t)
|
|
defer done()
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
|
|
defer cancel()
|
|
|
|
filter := influxdb.VariableFilter{}
|
|
if tt.args.orgID != nil {
|
|
filter.OrganizationID = tt.args.orgID
|
|
}
|
|
|
|
variables, err := s.FindVariables(ctx, filter, tt.args.findOpts)
|
|
diffPlatformErrors(tt.name, err, tt.wants.err, opPrefix, t)
|
|
|
|
if diff := cmp.Diff(variables, tt.wants.variables, variableCmpOptions...); diff != "" {
|
|
t.Errorf("variables are different -got/+want\ndiff %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// UpdateVariable tests influxdb.VariableService UpdateVariable interface method
|
|
func UpdateVariable(init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()), t *testing.T) {
|
|
type args struct {
|
|
id influxdb.ID
|
|
update *influxdb.VariableUpdate
|
|
}
|
|
type wants struct {
|
|
err *influxdb.Error
|
|
variables []*influxdb.Variable
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fields VariableFields
|
|
args args
|
|
wants wants
|
|
}{
|
|
{
|
|
name: "updating a variable's name",
|
|
fields: VariableFields{
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "existing-variable-a",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "existing-variable-b",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idB),
|
|
update: &influxdb.VariableUpdate{
|
|
Name: "new-variable-b-name",
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: nil,
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "existing-variable-a",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "new-variable-b-name",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "updating a non-existent variable fails",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idA),
|
|
update: &influxdb.VariableUpdate{
|
|
Name: "howdy",
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Op: influxdb.OpUpdateVariable,
|
|
Msg: influxdb.ErrVariableNotFound,
|
|
Code: influxdb.ENotFound,
|
|
},
|
|
variables: []*influxdb.Variable{},
|
|
},
|
|
},
|
|
{
|
|
name: "updating fails when variable name already exists",
|
|
fields: VariableFields{
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "variable-a",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "variable-b",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idB),
|
|
update: &influxdb.VariableUpdate{
|
|
Name: "variable-a",
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Code: influxdb.EConflict,
|
|
Msg: "variable entity update conflicts with an existing entity",
|
|
},
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "variable-a",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "variable-b",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "trims the variable name but updating fails when variable name already exists",
|
|
fields: VariableFields{
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "variable-a",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "variable-b",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idB),
|
|
update: &influxdb.VariableUpdate{
|
|
Name: " variable-a ",
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Code: influxdb.EConflict,
|
|
Msg: "variable entity update conflicts with an existing entity",
|
|
},
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "variable-a",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
{
|
|
ID: MustIDBase16(idB),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "variable-b",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s, _, done := init(tt.fields, t)
|
|
defer done()
|
|
ctx := context.Background()
|
|
|
|
variable, err := s.UpdateVariable(ctx, tt.args.id, tt.args.update)
|
|
influxErrsEqual(t, tt.wants.err, err)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if variable != nil {
|
|
if tt.args.update.Name != "" && variable.Name != tt.args.update.Name {
|
|
t.Fatalf("variable name not updated")
|
|
}
|
|
}
|
|
|
|
variables, err := s.FindVariables(ctx, influxdb.VariableFilter{})
|
|
if err != nil {
|
|
t.Fatalf("failed to retrieve variables: %v", err)
|
|
}
|
|
if diff := cmp.Diff(variables, tt.wants.variables, variableCmpOptions...); diff != "" {
|
|
t.Fatalf("found unexpected variables -got/+want\ndiff %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// ReplaceVariable tests influxdb.VariableService ReplaceVariable interface method
|
|
func ReplaceVariable(init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()), t *testing.T) {
|
|
type args struct {
|
|
id influxdb.ID
|
|
newVariable *influxdb.Variable
|
|
}
|
|
type wants struct {
|
|
err *influxdb.Error
|
|
variables []*influxdb.Variable
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fields VariableFields
|
|
args args
|
|
wants wants
|
|
}{
|
|
{
|
|
name: "updating a variable's name",
|
|
fields: VariableFields{
|
|
TimeGenerator: fakeGenerator,
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "existing-variable",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idB),
|
|
newVariable: &influxdb.Variable{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "renamed-variable",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
wants: wants{
|
|
err: nil,
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(7),
|
|
Name: "renamed-variable",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: fakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s, _, done := init(tt.fields, t)
|
|
defer done()
|
|
ctx := context.Background()
|
|
|
|
err := s.ReplaceVariable(ctx, tt.args.newVariable)
|
|
influxErrsEqual(t, tt.wants.err, err)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
variable, err := s.FindVariableByID(ctx, tt.args.id)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if variable != nil {
|
|
if tt.args.newVariable.Name != "" && variable.Name != tt.args.newVariable.Name {
|
|
t.Fatalf("variable name not updated")
|
|
}
|
|
}
|
|
|
|
variables, err := s.FindVariables(ctx, influxdb.VariableFilter{})
|
|
if err != nil {
|
|
t.Fatalf("failed to retrieve variables: %v", err)
|
|
}
|
|
if diff := cmp.Diff(variables, tt.wants.variables, variableCmpOptions...); diff != "" {
|
|
t.Fatalf("found unexpected variables -got/+want\ndiff %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// DeleteVariable tests influxdb.VariableService DeleteVariable interface method
|
|
func DeleteVariable(init func(VariableFields, *testing.T) (influxdb.VariableService, string, func()), t *testing.T) {
|
|
type args struct {
|
|
id influxdb.ID
|
|
}
|
|
type wants struct {
|
|
err *influxdb.Error
|
|
variables []*influxdb.Variable
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fields VariableFields
|
|
args args
|
|
wants wants
|
|
}{
|
|
{
|
|
name: "deleting a variable",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idA),
|
|
OrganizationID: influxdb.ID(9),
|
|
Name: "m",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: oldFakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idA),
|
|
},
|
|
wants: wants{
|
|
err: nil,
|
|
variables: []*influxdb.Variable{},
|
|
},
|
|
},
|
|
{
|
|
name: "deleting a variable that doesn't exist",
|
|
fields: VariableFields{
|
|
Variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idD),
|
|
OrganizationID: influxdb.ID(1),
|
|
Name: "existing-variable",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: oldFakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
args: args{
|
|
id: MustIDBase16(idB),
|
|
},
|
|
wants: wants{
|
|
err: &influxdb.Error{
|
|
Code: influxdb.ENotFound,
|
|
Op: influxdb.OpDeleteVariable,
|
|
Msg: influxdb.ErrVariableNotFound,
|
|
},
|
|
variables: []*influxdb.Variable{
|
|
{
|
|
ID: MustIDBase16(idD),
|
|
OrganizationID: influxdb.ID(1),
|
|
Name: "existing-variable",
|
|
Arguments: &influxdb.VariableArguments{
|
|
Type: "constant",
|
|
Values: influxdb.VariableConstantValues{},
|
|
},
|
|
CRUDLog: influxdb.CRUDLog{
|
|
CreatedAt: oldFakeDate,
|
|
UpdatedAt: oldFakeDate,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
s, _, done := init(tt.fields, t)
|
|
defer done()
|
|
ctx := context.Background()
|
|
|
|
defer s.ReplaceVariable(ctx, &influxdb.Variable{
|
|
ID: tt.args.id,
|
|
OrganizationID: influxdb.ID(1),
|
|
})
|
|
|
|
err := s.DeleteVariable(ctx, tt.args.id)
|
|
if err != nil {
|
|
if tt.wants.err == nil {
|
|
require.NoError(t, err)
|
|
}
|
|
iErr, ok := err.(*influxdb.Error)
|
|
require.True(t, ok)
|
|
assert.Equal(t, iErr.Code, tt.wants.err.Code)
|
|
assert.Equal(t, strings.HasPrefix(iErr.Error(), tt.wants.err.Error()), true)
|
|
return
|
|
}
|
|
|
|
variables, err := s.FindVariables(ctx, influxdb.VariableFilter{})
|
|
if err != nil {
|
|
t.Fatalf("failed to retrieve variables: %v", err)
|
|
}
|
|
if diff := cmp.Diff(variables, tt.wants.variables, variableCmpOptions...); diff != "" {
|
|
t.Fatalf("found unexpected variables -got/+want\ndiff %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|