func watchWithIndex(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("\nwatchWithIndex")
tree := "indexTree"
subtree := tree + "/subtree"
key := subtree + "/watchWithIndex"
key1 := subtree + "/watchWithIndex21"
kv.DeleteTree(tree)
kvp, err := kv.Create(key, []byte("bar"), 0)
assert.NoError(t, err, "Unexpected error in create: %v", err)
time.Sleep(time.Millisecond * 100)
waitIndex := kvp.ModifiedIndex + 2
watchData := watchData{
t: t,
key: key,
localIndex: waitIndex,
}
err = kv.WatchTree(tree, waitIndex, &watchData, watchWithIndexCb)
if err != nil {
fmt.Printf("Cannot test watchTree for watchWithIndex: %v", err)
return
}
// Should not get updates for these
kv.Put(key, []byte("bar1"), 0)
kv.Put(key, []byte("bar1"), 0)
// Should get updates for these
kv.Put(key, []byte("bar2"), 0)
kv.Create(key1, []byte("bar"), 0)
kv.Delete(key)
}
func getInterface(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("getInterface")
expected := struct {
N int
S string
}{
N: 10,
S: "Ten",
}
actual := expected
actual.N = 0
actual.S = "zero"
key := "DEADBEEF"
_, err := kv.Delete(key)
_, err = kv.Put(key, &expected, 0)
assert.NoError(t, err, "Failed in Put")
_, err = kv.GetVal(key, &actual)
assert.NoError(t, err, "Failed in Get")
assert.Equal(t, expected, actual, "Expected %#v but got %#v",
expected, actual)
}
func watchUpdate(kv kvdb.Kvdb, data *watchData) error {
var err error
var kvp *kvdb.KVPair
data.reader, data.writer = 0, 0
atomic.AddInt32(&data.writer, 1)
// whichKey = 1 : key
// whichKey = 0 : otherKey
atomic.SwapInt32(&data.whichKey, 1)
data.action = kvdb.KVCreate
fmt.Printf("-")
kvp, err = kv.Create(data.key, []byte("bar"), 0)
for i := 0; i < data.iterations && err == nil; i++ {
fmt.Printf("-")
for data.writer != data.reader {
time.Sleep(time.Millisecond * 100)
}
atomic.AddInt32(&data.writer, 1)
data.action = kvdb.KVSet
kvp, err = kv.Put(data.key, []byte("bar"), 0)
data.updateIndex = kvp.KVDBIndex
assert.NoError(data.t, err, "Unexpected error in Put")
}
fmt.Printf("-")
for data.writer != data.reader {
time.Sleep(time.Millisecond * 100)
}
atomic.AddInt32(&data.writer, 1)
// Delete key
data.action = kvdb.KVDelete
kv.Delete(data.key)
fmt.Printf("-")
for data.writer != data.reader {
time.Sleep(time.Millisecond * 100)
}
atomic.AddInt32(&data.writer, 1)
atomic.SwapInt32(&data.whichKey, 0)
data.action = kvdb.KVDelete
// Delete otherKey
kv.Delete(data.otherKey)
fmt.Printf("-")
for data.writer != data.reader {
time.Sleep(time.Millisecond * 100)
}
atomic.AddInt32(&data.writer, 1)
atomic.SwapInt32(&data.whichKey, 1)
data.action = kvdb.KVCreate
_, err = kv.Create(data.key, []byte(data.stop), 0)
return err
}
func create(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("create")
key := "///create/foo"
kv.Delete(key)
kvp, err := kv.Create(key, []byte("bar"), 0)
require.NoError(t, err, "Error on create")
defer func() {
kv.Delete(key)
}()
assert.Equal(t, kvp.Action, kvdb.KVCreate,
"Expected action KVCreate, actual %v", kvp.Action)
_, err = kv.Create(key, []byte("bar"), 0)
assert.Error(t, err, "Create on existing key should have errored.")
}
func cas(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("\ncas")
key := "foo/docker"
val := "great"
defer func() {
kv.Delete(key)
}()
kvPair, err := kv.Put(key, []byte(val), 0)
assert.NoError(t, err, "Unxpected error in Put")
kvPair, err = kv.Get(key)
assert.NoError(t, err, "Failed in Get")
_, err = kv.CompareAndSet(kvPair, kvdb.KVFlags(0), []byte("badval"))
assert.Error(t, err, "CompareAndSet should fail on an incorrect previous value")
//assert.EqualError(t, err, kvdb.ErrValueMismatch.Error(), "CompareAndSet should return value mismatch error")
copyKVPair := *kvPair
copyKVPair.ModifiedIndex++
_, err = kv.CompareAndSet(©KVPair, kvdb.KVModifiedIndex, nil)
assert.Error(t, err, "CompareAndSet should fail on an incorrect modified index")
//kvPair.ModifiedIndex--
copyKVPair.ModifiedIndex--
kvPair, err = kv.CompareAndSet(©KVPair, kvdb.KVModifiedIndex, nil)
assert.NoError(t, err, "CompareAndSet should succeed on an correct modified index")
kvPairNew, err := kv.CompareAndSet(kvPair, kvdb.KVFlags(0), []byte(val))
if err != nil {
// consul does not handle this kind of compare and set
assert.EqualError(t, err, kvdb.ErrNotSupported.Error(), "Invalid error returned : %v", err)
} else {
assert.NoError(t, err, "CompareAndSet should succeed on an correct value")
}
if kvPairNew != nil {
kvPair = kvPairNew
}
kvPair, err = kv.CompareAndSet(kvPair, kvdb.KVModifiedIndex, []byte(val))
assert.NoError(t, err, "CompareAndSet should succeed on an correct value and modified index")
}
func watchKey(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("\nwatchKey")
watchData := watchData{
t: t,
key: "tree/key1",
otherKey: "tree/otherKey1",
stop: "stop",
iterations: 2,
}
kv.Delete(watchData.key)
kv.Delete(watchData.otherKey)
// First create a key. We should not get update for this create.
_, err := kv.Create(watchData.otherKey, []byte("bar"), 0)
// Let the create operation finish and then start the watch
time.Sleep(time.Second)
err = kv.WatchKey(watchData.otherKey, 0, &watchData, watchFn)
if err != nil {
fmt.Printf("Cannot test watchKey: %v\n", err)
return
}
err = kv.WatchKey(watchData.key, 0, &watchData, watchFn)
if err != nil {
fmt.Printf("Cannot test watchKey: %v\n", err)
return
}
go watchUpdate(kv, &watchData)
for watchData.watchStopped == false {
time.Sleep(time.Millisecond * 100)
}
// Stop the second watch
atomic.SwapInt32(&watchData.whichKey, 0)
watchData.action = kvdb.KVCreate
_, err = kv.Create(watchData.otherKey, []byte(watchData.stop), 0)
}
func get(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("get")
kvPair, err := kv.Get("DEADCAFE")
assert.Error(t, err, "Expecting error value for non-existent value")
key := "foo/docker"
val := "great"
defer func() {
kv.Delete(key)
}()
kvPair, err = kv.Put(key, []byte(val), 0)
assert.NoError(t, err, "Unexpected error in Put")
kvPair, err = kv.Get(key)
assert.NoError(t, err, "Failed in Get")
assert.Equal(t, key, kvPair.Key, "Key mismatch in Get")
assert.Equal(t, string(kvPair.Value), val, "value mismatch in Get")
}
func update(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("update")
key := "update/foo"
kv.Delete(key)
kvp, err := kv.Update(key, []byte("bar"), 0)
assert.Error(t, err, "Update should error on non-existent key")
defer func() {
kv.Delete(key)
}()
kvp, err = kv.Create(key, []byte("bar"), 0)
assert.NoError(t, err, "Unexpected error on create")
kvp, err = kv.Update(key, []byte("bar"), 0)
assert.NoError(t, err, "Unexpected error on update")
assert.Equal(t, kvp.Action, kvdb.KVSet,
"Expected action KVSet, actual %v", kvp.Action)
}
func createWithTTL(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("create with ttl")
key := "create/foo"
kv.Delete(key)
assert.NotNil(t, kv, "Default KVDB is not set")
_, err := kv.Create(key, []byte("bar"), 6)
if err != nil {
// Consul does not support ttl less than 10
assert.EqualError(t, err, kvdb.ErrTTLNotSupported.Error(), "ttl not supported")
_, err := kv.Create(key, []byte("bar"), 20)
assert.NoError(t, err, "Error on create")
// Consul doubles the ttl value
time.Sleep(time.Second * 20)
_, err = kv.Get(key)
assert.Error(t, err, "Expecting error value for expired value")
} else {
assert.NoError(t, err, "Error on create")
time.Sleep(time.Second * 7)
_, err = kv.Get(key)
assert.Error(t, err, "Expecting error value for expired value")
}
}
func watchTree(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("\nwatchTree")
tree := "tree"
watchData := watchData{
t: t,
key: tree + "/key",
otherKey: tree + "/otherKey",
stop: "stop",
iterations: 2,
}
_, err := kv.Delete(watchData.key)
_, err = kv.Delete(watchData.otherKey)
// First create a tree to watch for. We should not get update for this create.
_, err = kv.Create(watchData.otherKey, []byte("bar"), 0)
// Let the create operation finish and then start the watch
time.Sleep(time.Second)
err = kv.WatchTree(tree, 0, &watchData, watchFn)
if err != nil {
fmt.Printf("Cannot test watchKey: %v\n", err)
return
}
// Sleep for sometime before calling the watchUpdate go routine.
time.Sleep(time.Millisecond * 100)
go randomUpdate(kv, &watchData)
go watchUpdate(kv, &watchData)
for watchData.watchStopped == false {
time.Sleep(time.Millisecond * 100)
}
}
func deleteKey(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("deleteKey")
key := "delete_key"
_, err := kv.Delete(key)
_, err = kv.Put(key, []byte("delete_me"), 0)
assert.NoError(t, err, "Unexpected error on Put")
_, err = kv.Get(key)
assert.NoError(t, err, "Unexpected error on Get")
_, err = kv.Delete(key)
assert.NoError(t, err, "Unexpected error on Delete")
_, err = kv.Get(key)
assert.Error(t, err, "Get should fail on deleted key")
_, err = kv.Delete(key)
assert.Error(t, err, "Delete should fail on non existent key")
}
