308 lines
7.2 KiB
Go
308 lines
7.2 KiB
Go
package api
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/hashicorp/nomad/api/internal/testutil"
|
|
"github.com/shoenig/test/must"
|
|
)
|
|
|
|
func TestVariables_SimpleCRUD(t *testing.T) {
|
|
testutil.Parallel(t)
|
|
|
|
c, s := makeClient(t, nil, nil)
|
|
defer s.Stop()
|
|
|
|
nsv := c.Variables()
|
|
sv1 := NewVariable("my/first/variable")
|
|
sv1.Namespace = "default"
|
|
sv1.Items["k1"] = "v1"
|
|
sv1.Items["k2"] = "v2"
|
|
|
|
sv2 := sv1.Copy()
|
|
sv2.Path = "other/variable/b"
|
|
sv2.Items["k1"] = "otherv1"
|
|
sv2.Items["k2"] = "otherv2"
|
|
|
|
t.Run("1 fail create when no items", func(t *testing.T) {
|
|
_, _, err := nsv.Create(&Variable{Path: "bad/var"}, nil)
|
|
must.ErrorContains(t, err, "Unexpected response code: 400 (variable missing required Items object)")
|
|
})
|
|
|
|
t.Run("2 create sv1", func(t *testing.T) {
|
|
get, _, err := nsv.Create(sv1, nil)
|
|
must.NoError(t, err)
|
|
must.NotNil(t, get)
|
|
must.Positive(t, get.CreateIndex)
|
|
must.Positive(t, get.CreateTime)
|
|
must.Positive(t, get.ModifyIndex)
|
|
must.Positive(t, get.ModifyTime)
|
|
must.Eq(t, sv1.Items, get.Items)
|
|
*sv1 = *get
|
|
})
|
|
|
|
t.Run("2 create sv2", func(t *testing.T) {
|
|
|
|
var err error
|
|
sv2, _, err = nsv.Create(sv2, nil)
|
|
must.NoError(t, err)
|
|
})
|
|
|
|
// TODO: Need to prevent no-op modifications from happening server-side
|
|
// t.Run("3 update sv1 no change", func(t *testing.T) {
|
|
|
|
// get, _, err := nsv.Update(sv1, nil)
|
|
// require.NoError(t, err)
|
|
// require.NotNil(t, get)
|
|
// require.Equal(t, sv1.ModifyIndex, get.ModifyIndex, "ModifyIndex should not change")
|
|
// require.Equal(t, sv1.Items, get.Items)
|
|
// *sv1 = *get
|
|
// })
|
|
|
|
t.Run("4 update sv1", func(t *testing.T) {
|
|
|
|
sv1.Items["new-hotness"] = "yeah!"
|
|
get, _, err := nsv.Update(sv1, nil)
|
|
must.NoError(t, err)
|
|
must.NotNil(t, get)
|
|
must.NotEq(t, sv1.ModifyIndex, get.ModifyIndex)
|
|
must.Eq(t, sv1.Items, get.Items)
|
|
*sv1 = *get
|
|
})
|
|
|
|
t.Run("5 list vars", func(t *testing.T) {
|
|
l, _, err := nsv.List(nil)
|
|
must.NoError(t, err)
|
|
must.Len(t, 2, l)
|
|
must.Eq(t, []*VariableMetadata{sv1.Metadata(), sv2.Metadata()}, l)
|
|
})
|
|
|
|
t.Run("5a list vars opts", func(t *testing.T) {
|
|
// Since there are two vars in the backend, we should
|
|
// get a NextToken with a page size of 1
|
|
l, qm, err := nsv.List(&QueryOptions{PerPage: 1})
|
|
must.NoError(t, err)
|
|
must.Len(t, 1, l)
|
|
must.Eq(t, sv1.Metadata(), l[0])
|
|
must.NotNil(t, qm.NextToken)
|
|
})
|
|
|
|
t.Run("5b prefixlist", func(t *testing.T) {
|
|
l, _, err := nsv.PrefixList("my", nil)
|
|
must.NoError(t, err)
|
|
must.Len(t, 1, l)
|
|
must.Eq(t, sv1.Metadata(), l[0])
|
|
})
|
|
|
|
t.Run("6 delete sv1", func(t *testing.T) {
|
|
_, err := nsv.Delete(sv1.Path, nil)
|
|
must.NoError(t, err)
|
|
_, _, err = nsv.Read(sv1.Path, nil)
|
|
must.ErrorIs(t, err, ErrVariablePathNotFound)
|
|
})
|
|
|
|
t.Run("7 list vars after delete", func(t *testing.T) {
|
|
l, _, err := nsv.List(nil)
|
|
must.NoError(t, err)
|
|
must.NotNil(t, l)
|
|
must.Len(t, 1, l)
|
|
})
|
|
}
|
|
|
|
func TestVariables_CRUDWithCAS(t *testing.T) {
|
|
testutil.Parallel(t)
|
|
|
|
c, s := makeClient(t, nil, nil)
|
|
defer s.Stop()
|
|
|
|
nsv := c.Variables()
|
|
sv1 := &Variable{
|
|
Path: "cas/variable/a",
|
|
Items: map[string]string{
|
|
"key1": "value1",
|
|
"key2": "value2",
|
|
},
|
|
}
|
|
|
|
// Create sv1: should pass without issue
|
|
get, _, err := nsv.Create(sv1, nil)
|
|
must.NoError(t, err)
|
|
must.NotNil(t, get)
|
|
must.Positive(t, get.CreateIndex)
|
|
must.Positive(t, get.CreateTime)
|
|
must.Positive(t, get.ModifyIndex)
|
|
must.Positive(t, get.ModifyTime)
|
|
must.Eq(t, sv1.Items, get.Items)
|
|
|
|
// Update sv1 with CAS:
|
|
|
|
// - perform out of band upsert
|
|
oobUpdate := sv1.Copy()
|
|
oobUpdate.Items["new-hotness"] = "yeah!"
|
|
nowVal, _, err := nsv.Update(oobUpdate, nil)
|
|
must.NoError(t, err)
|
|
|
|
// - try to do an update with sv1's old state; should fail
|
|
_, _, err = nsv.CheckedUpdate(sv1, nil)
|
|
must.Error(t, err)
|
|
|
|
// - expect the error to be an ErrCASConflict, so we can cast
|
|
// to it and retrieve the Conflict value
|
|
var conflictErr ErrCASConflict
|
|
must.True(t, errors.As(err, &conflictErr))
|
|
must.Eq(t, nowVal, conflictErr.Conflict)
|
|
|
|
// Delete CAS: try to delete sv1 at old ModifyIndex; should
|
|
// return an ErrCASConflict. Check Conflict.
|
|
_, err = nsv.CheckedDelete(sv1.Path, sv1.ModifyIndex, nil)
|
|
must.True(t, errors.As(err, &conflictErr))
|
|
must.Eq(t, nowVal, conflictErr.Conflict)
|
|
|
|
// Delete CAS: delete at the current index; should succeed.
|
|
_, err = nsv.CheckedDelete(sv1.Path, nowVal.ModifyIndex, nil)
|
|
must.NoError(t, err)
|
|
}
|
|
|
|
func TestVariables_Read(t *testing.T) {
|
|
testutil.Parallel(t)
|
|
|
|
c, s := makeClient(t, nil, nil)
|
|
defer s.Stop()
|
|
|
|
nsv := c.Variables()
|
|
tID := fmt.Sprint(time.Now().UTC().UnixNano())
|
|
sv1 := Variable{
|
|
Namespace: "default",
|
|
Path: tID + "/sv1",
|
|
Items: map[string]string{
|
|
"kv1": "val1",
|
|
"kv2": "val2",
|
|
},
|
|
}
|
|
writeTestVariable(t, c, &sv1)
|
|
|
|
testCases := []struct {
|
|
name string
|
|
path string
|
|
expectedError error
|
|
checkValue bool
|
|
expectedValue *Variable
|
|
}{
|
|
{
|
|
name: "not found",
|
|
path: tID + "/not/found",
|
|
expectedError: ErrVariablePathNotFound,
|
|
checkValue: true,
|
|
expectedValue: nil,
|
|
},
|
|
{
|
|
name: "found",
|
|
path: sv1.Path,
|
|
checkValue: true,
|
|
expectedValue: &sv1,
|
|
},
|
|
}
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
get, _, err := nsv.Read(tc.path, nil)
|
|
if tc.expectedError != nil {
|
|
must.ErrorIs(t, err, tc.expectedError)
|
|
} else {
|
|
must.NoError(t, err)
|
|
}
|
|
if tc.checkValue {
|
|
if tc.expectedValue != nil {
|
|
must.NotNil(t, get)
|
|
must.Eq(t, tc.expectedValue, get)
|
|
} else {
|
|
must.Nil(t, get)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestVariables_GetVariableItems(t *testing.T) {
|
|
testutil.Parallel(t)
|
|
|
|
c, s := makeClient(t, nil, nil)
|
|
defer s.Stop()
|
|
|
|
nsv := c.Variables()
|
|
tID := fmt.Sprint(time.Now().UTC().UnixNano())
|
|
sv1 := Variable{
|
|
Namespace: "default",
|
|
Path: tID + "/sv1",
|
|
Items: map[string]string{
|
|
"kv1": "val1",
|
|
"kv2": "val2",
|
|
},
|
|
}
|
|
writeTestVariable(t, c, &sv1)
|
|
|
|
testCases := []struct {
|
|
name string
|
|
path string
|
|
expectedError error
|
|
checkValue bool
|
|
expectedValue VariableItems
|
|
}{
|
|
{
|
|
name: "not found",
|
|
path: tID + "/not/found",
|
|
expectedError: ErrVariablePathNotFound,
|
|
checkValue: true,
|
|
expectedValue: nil,
|
|
},
|
|
{
|
|
name: "found",
|
|
path: sv1.Path,
|
|
checkValue: true,
|
|
expectedValue: sv1.Items,
|
|
},
|
|
}
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
get, _, err := nsv.GetVariableItems(tc.path, nil)
|
|
if tc.expectedError != nil {
|
|
must.ErrorIs(t, err, tc.expectedError)
|
|
} else {
|
|
must.NoError(t, err)
|
|
}
|
|
if tc.checkValue {
|
|
if tc.expectedValue != nil {
|
|
must.NotNil(t, get)
|
|
must.Eq(t, tc.expectedValue, get)
|
|
} else {
|
|
must.Nil(t, get)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func writeTestVariable(t *testing.T, c *Client, sv *Variable) {
|
|
_, err := c.put("/v1/var/"+sv.Path, sv, sv, nil)
|
|
must.NoError(t, err, must.Sprint("failed writing test variable"))
|
|
must.NoError(t, err, must.Sprint("failed writing test variable"))
|
|
}
|
|
|
|
func TestVariable_CreateReturnsContent(t *testing.T) {
|
|
c, s := makeClient(t, nil, nil)
|
|
defer s.Stop()
|
|
|
|
nsv := c.Variables()
|
|
sv1 := NewVariable("my/first/variable")
|
|
sv1.Namespace = "default"
|
|
sv1.Items["k1"] = "v1"
|
|
sv1.Items["k2"] = "v2"
|
|
|
|
sv1n, _, err := nsv.Create(sv1, nil)
|
|
must.NoError(t, err)
|
|
must.NotNil(t, sv1n)
|
|
must.Eq(t, sv1.Items, sv1n.Items)
|
|
}
|