Pruning dependencies with `dep prune`

Signed-off-by: Dave Henderson <dhenderson@gmail.com>

1 files changed, 0 insertions, 622 deletions

diff --git a/vendor/github.com/docker/libkv/testutils/utils.go b/vendor/github.com/docker/libkv/testutils/utils.go
deleted file mode 100644
index 5385bac6..00000000
--- a/vendor/github.com/docker/libkv/testutils/utils.go
+++ /dev/null
@@ -1,622 +0,0 @@
-package testutils
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/docker/libkv/store"
-	"github.com/stretchr/testify/assert"
-)
-
-// RunTestCommon tests the minimal required APIs which
-// should be supported by all K/V backends
-func RunTestCommon(t *testing.T, kv store.Store) {
-	testPutGetDeleteExists(t, kv)
-	testList(t, kv)
-	testDeleteTree(t, kv)
-}
-
-// RunTestAtomic tests the Atomic operations by the K/V
-// backends
-func RunTestAtomic(t *testing.T, kv store.Store) {
-	testAtomicPut(t, kv)
-	testAtomicPutCreate(t, kv)
-	testAtomicPutWithSlashSuffixKey(t, kv)
-	testAtomicDelete(t, kv)
-}
-
-// RunTestWatch tests the watch/monitor APIs supported
-// by the K/V backends.
-func RunTestWatch(t *testing.T, kv store.Store) {
-	testWatch(t, kv)
-	testWatchTree(t, kv)
-}
-
-// RunTestLock tests the KV pair Lock/Unlock APIs supported
-// by the K/V backends.
-func RunTestLock(t *testing.T, kv store.Store) {
-	testLockUnlock(t, kv)
-}
-
-// RunTestLockTTL tests the KV pair Lock with TTL APIs supported
-// by the K/V backends.
-func RunTestLockTTL(t *testing.T, kv store.Store, backup store.Store) {
-	testLockTTL(t, kv, backup)
-}
-
-// RunTestTTL tests the TTL functionality of the K/V backend.
-func RunTestTTL(t *testing.T, kv store.Store, backup store.Store) {
-	testPutTTL(t, kv, backup)
-}
-
-func testPutGetDeleteExists(t *testing.T, kv store.Store) {
-	// Get a not exist key should return ErrKeyNotFound
-	pair, err := kv.Get("testPutGetDelete_not_exist_key")
-	assert.Equal(t, store.ErrKeyNotFound, err)
-
-	value := []byte("bar")
-	for _, key := range []string{
-		"testPutGetDeleteExists",
-		"testPutGetDeleteExists/",
-		"testPutGetDeleteExists/testbar/",
-		"testPutGetDeleteExists/testbar/testfoobar",
-	} {
-		failMsg := fmt.Sprintf("Fail key %s", key)
-
-		// Put the key
-		err = kv.Put(key, value, nil)
-		assert.NoError(t, err, failMsg)
-
-		// Get should return the value and an incremented index
-		pair, err = kv.Get(key)
-		assert.NoError(t, err, failMsg)
-		if assert.NotNil(t, pair, failMsg) {
-			assert.NotNil(t, pair.Value, failMsg)
-		}
-		assert.Equal(t, pair.Value, value, failMsg)
-		assert.NotEqual(t, pair.LastIndex, 0, failMsg)
-
-		// Exists should return true
-		exists, err := kv.Exists(key)
-		assert.NoError(t, err, failMsg)
-		assert.True(t, exists, failMsg)
-
-		// Delete the key
-		err = kv.Delete(key)
-		assert.NoError(t, err, failMsg)
-
-		// Get should fail
-		pair, err = kv.Get(key)
-		assert.Error(t, err, failMsg)
-		assert.Nil(t, pair, failMsg)
-
-		// Exists should return false
-		exists, err = kv.Exists(key)
-		assert.NoError(t, err, failMsg)
-		assert.False(t, exists, failMsg)
-	}
-}
-
-func testWatch(t *testing.T, kv store.Store) {
-	key := "testWatch"
-	value := []byte("world")
-	newValue := []byte("world!")
-
-	// Put the key
-	err := kv.Put(key, value, nil)
-	assert.NoError(t, err)
-
-	stopCh := make(<-chan struct{})
-	events, err := kv.Watch(key, stopCh)
-	assert.NoError(t, err)
-	assert.NotNil(t, events)
-
-	// Update loop
-	go func() {
-		timeout := time.After(1 * time.Second)
-		tick := time.Tick(250 * time.Millisecond)
-		for {
-			select {
-			case <-timeout:
-				return
-			case <-tick:
-				err := kv.Put(key, newValue, nil)
-				if assert.NoError(t, err) {
-					continue
-				}
-				return
-			}
-		}
-	}()
-
-	// Check for updates
-	eventCount := 1
-	for {
-		select {
-		case event := <-events:
-			assert.NotNil(t, event)
-			if eventCount == 1 {
-				assert.Equal(t, event.Key, key)
-				assert.Equal(t, event.Value, value)
-			} else {
-				assert.Equal(t, event.Key, key)
-				assert.Equal(t, event.Value, newValue)
-			}
-			eventCount++
-			// We received all the events we wanted to check
-			if eventCount >= 4 {
-				return
-			}
-		case <-time.After(4 * time.Second):
-			t.Fatal("Timeout reached")
-			return
-		}
-	}
-}
-
-func testWatchTree(t *testing.T, kv store.Store) {
-	dir := "testWatchTree"
-
-	node1 := "testWatchTree/node1"
-	value1 := []byte("node1")
-
-	node2 := "testWatchTree/node2"
-	value2 := []byte("node2")
-
-	node3 := "testWatchTree/node3"
-	value3 := []byte("node3")
-
-	err := kv.Put(node1, value1, nil)
-	assert.NoError(t, err)
-	err = kv.Put(node2, value2, nil)
-	assert.NoError(t, err)
-	err = kv.Put(node3, value3, nil)
-	assert.NoError(t, err)
-
-	stopCh := make(<-chan struct{})
-	events, err := kv.WatchTree(dir, stopCh)
-	assert.NoError(t, err)
-	assert.NotNil(t, events)
-
-	// Update loop
-	go func() {
-		timeout := time.After(500 * time.Millisecond)
-		for {
-			select {
-			case <-timeout:
-				err := kv.Delete(node3)
-				assert.NoError(t, err)
-				return
-			}
-		}
-	}()
-
-	// Check for updates
-	eventCount := 1
-	for {
-		select {
-		case event := <-events:
-			assert.NotNil(t, event)
-			// We received the Delete event on a child node
-			// Exit test successfully
-			if eventCount == 2 {
-				return
-			}
-			eventCount++
-		case <-time.After(4 * time.Second):
-			t.Fatal("Timeout reached")
-			return
-		}
-	}
-}
-
-func testAtomicPut(t *testing.T, kv store.Store) {
-	key := "testAtomicPut"
-	value := []byte("world")
-
-	// Put the key
-	err := kv.Put(key, value, nil)
-	assert.NoError(t, err)
-
-	// Get should return the value and an incremented index
-	pair, err := kv.Get(key)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, value)
-	assert.NotEqual(t, pair.LastIndex, 0)
-
-	// This CAS should fail: previous exists.
-	success, _, err := kv.AtomicPut(key, []byte("WORLD"), nil, nil)
-	assert.Error(t, err)
-	assert.False(t, success)
-
-	// This CAS should succeed
-	success, _, err = kv.AtomicPut(key, []byte("WORLD"), pair, nil)
-	assert.NoError(t, err)
-	assert.True(t, success)
-
-	// This CAS should fail, key exists.
-	pair.LastIndex = 6744
-	success, _, err = kv.AtomicPut(key, []byte("WORLDWORLD"), pair, nil)
-	assert.Error(t, err)
-	assert.False(t, success)
-}
-
-func testAtomicPutCreate(t *testing.T, kv store.Store) {
-	// Use a key in a new directory to ensure Stores will create directories
-	// that don't yet exist.
-	key := "testAtomicPutCreate/create"
-	value := []byte("putcreate")
-
-	// AtomicPut the key, previous = nil indicates create.
-	success, _, err := kv.AtomicPut(key, value, nil, nil)
-	assert.NoError(t, err)
-	assert.True(t, success)
-
-	// Get should return the value and an incremented index
-	pair, err := kv.Get(key)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, value)
-
-	// Attempting to create again should fail.
-	success, _, err = kv.AtomicPut(key, value, nil, nil)
-	assert.Error(t, store.ErrKeyExists)
-	assert.False(t, success)
-
-	// This CAS should succeed, since it has the value from Get()
-	success, _, err = kv.AtomicPut(key, []byte("PUTCREATE"), pair, nil)
-	assert.NoError(t, err)
-	assert.True(t, success)
-}
-
-func testAtomicPutWithSlashSuffixKey(t *testing.T, kv store.Store) {
-	k1 := "testAtomicPutWithSlashSuffixKey/key/"
-	success, _, err := kv.AtomicPut(k1, []byte{}, nil, nil)
-	assert.Nil(t, err)
-	assert.True(t, success)
-}
-
-func testAtomicDelete(t *testing.T, kv store.Store) {
-	key := "testAtomicDelete"
-	value := []byte("world")
-
-	// Put the key
-	err := kv.Put(key, value, nil)
-	assert.NoError(t, err)
-
-	// Get should return the value and an incremented index
-	pair, err := kv.Get(key)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, value)
-	assert.NotEqual(t, pair.LastIndex, 0)
-
-	tempIndex := pair.LastIndex
-
-	// AtomicDelete should fail
-	pair.LastIndex = 6744
-	success, err := kv.AtomicDelete(key, pair)
-	assert.Error(t, err)
-	assert.False(t, success)
-
-	// AtomicDelete should succeed
-	pair.LastIndex = tempIndex
-	success, err = kv.AtomicDelete(key, pair)
-	assert.NoError(t, err)
-	assert.True(t, success)
-
-	// Delete a non-existent key; should fail
-	success, err = kv.AtomicDelete(key, pair)
-	assert.Error(t, store.ErrKeyNotFound)
-	assert.False(t, success)
-}
-
-func testLockUnlock(t *testing.T, kv store.Store) {
-	key := "testLockUnlock"
-	value := []byte("bar")
-
-	// We should be able to create a new lock on key
-	lock, err := kv.NewLock(key, &store.LockOptions{Value: value, TTL: 2 * time.Second})
-	assert.NoError(t, err)
-	assert.NotNil(t, lock)
-
-	// Lock should successfully succeed or block
-	lockChan, err := lock.Lock(nil)
-	assert.NoError(t, err)
-	assert.NotNil(t, lockChan)
-
-	// Get should work
-	pair, err := kv.Get(key)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, value)
-	assert.NotEqual(t, pair.LastIndex, 0)
-
-	// Unlock should succeed
-	err = lock.Unlock()
-	assert.NoError(t, err)
-
-	// Lock should succeed again
-	lockChan, err = lock.Lock(nil)
-	assert.NoError(t, err)
-	assert.NotNil(t, lockChan)
-
-	// Get should work
-	pair, err = kv.Get(key)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, value)
-	assert.NotEqual(t, pair.LastIndex, 0)
-
-	err = lock.Unlock()
-	assert.NoError(t, err)
-}
-
-func testLockTTL(t *testing.T, kv store.Store, otherConn store.Store) {
-	key := "testLockTTL"
-	value := []byte("bar")
-
-	renewCh := make(chan struct{})
-
-	// We should be able to create a new lock on key
-	lock, err := otherConn.NewLock(key, &store.LockOptions{
-		Value:     value,
-		TTL:       2 * time.Second,
-		RenewLock: renewCh,
-	})
-	assert.NoError(t, err)
-	assert.NotNil(t, lock)
-
-	// Lock should successfully succeed
-	lockChan, err := lock.Lock(nil)
-	assert.NoError(t, err)
-	assert.NotNil(t, lockChan)
-
-	// Get should work
-	pair, err := otherConn.Get(key)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, value)
-	assert.NotEqual(t, pair.LastIndex, 0)
-
-	time.Sleep(3 * time.Second)
-
-	done := make(chan struct{})
-	stop := make(chan struct{})
-
-	value = []byte("foobar")
-
-	// Create a new lock with another connection
-	lock, err = kv.NewLock(
-		key,
-		&store.LockOptions{
-			Value: value,
-			TTL:   3 * time.Second,
-		},
-	)
-	assert.NoError(t, err)
-	assert.NotNil(t, lock)
-
-	// Lock should block, the session on the lock
-	// is still active and renewed periodically
-	go func(<-chan struct{}) {
-		_, _ = lock.Lock(stop)
-		done <- struct{}{}
-	}(done)
-
-	select {
-	case _ = <-done:
-		t.Fatal("Lock succeeded on a key that is supposed to be locked by another client")
-	case <-time.After(4 * time.Second):
-		// Stop requesting the lock as we are blocked as expected
-		stop <- struct{}{}
-		break
-	}
-
-	// Close the connection
-	otherConn.Close()
-
-	// Force stop the session renewal for the lock
-	close(renewCh)
-
-	// Let the session on the lock expire
-	time.Sleep(3 * time.Second)
-	locked := make(chan struct{})
-
-	// Lock should now succeed for the other client
-	go func(<-chan struct{}) {
-		lockChan, err = lock.Lock(nil)
-		assert.NoError(t, err)
-		assert.NotNil(t, lockChan)
-		locked <- struct{}{}
-	}(locked)
-
-	select {
-	case _ = <-locked:
-		break
-	case <-time.After(4 * time.Second):
-		t.Fatal("Unable to take the lock, timed out")
-	}
-
-	// Get should work with the new value
-	pair, err = kv.Get(key)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, value)
-	assert.NotEqual(t, pair.LastIndex, 0)
-
-	err = lock.Unlock()
-	assert.NoError(t, err)
-}
-
-func testPutTTL(t *testing.T, kv store.Store, otherConn store.Store) {
-	firstKey := "testPutTTL"
-	firstValue := []byte("foo")
-
-	secondKey := "second"
-	secondValue := []byte("bar")
-
-	// Put the first key with the Ephemeral flag
-	err := otherConn.Put(firstKey, firstValue, &store.WriteOptions{TTL: 2 * time.Second})
-	assert.NoError(t, err)
-
-	// Put a second key with the Ephemeral flag
-	err = otherConn.Put(secondKey, secondValue, &store.WriteOptions{TTL: 2 * time.Second})
-	assert.NoError(t, err)
-
-	// Get on firstKey should work
-	pair, err := kv.Get(firstKey)
-	assert.NoError(t, err)
-	assert.NotNil(t, pair)
-
-	// Get on secondKey should work
-	pair, err = kv.Get(secondKey)
-	assert.NoError(t, err)
-	assert.NotNil(t, pair)
-
-	// Close the connection
-	otherConn.Close()
-
-	// Let the session expire
-	time.Sleep(3 * time.Second)
-
-	// Get on firstKey shouldn't work
-	pair, err = kv.Get(firstKey)
-	assert.Error(t, err)
-	assert.Nil(t, pair)
-
-	// Get on secondKey shouldn't work
-	pair, err = kv.Get(secondKey)
-	assert.Error(t, err)
-	assert.Nil(t, pair)
-}
-
-func testList(t *testing.T, kv store.Store) {
-	prefix := "testList"
-
-	firstKey := "testList/first"
-	firstValue := []byte("first")
-
-	secondKey := "testList/second"
-	secondValue := []byte("second")
-
-	// Put the first key
-	err := kv.Put(firstKey, firstValue, nil)
-	assert.NoError(t, err)
-
-	// Put the second key
-	err = kv.Put(secondKey, secondValue, nil)
-	assert.NoError(t, err)
-
-	// List should work and return the two correct values
-	for _, parent := range []string{prefix, prefix + "/"} {
-		pairs, err := kv.List(parent)
-		assert.NoError(t, err)
-		if assert.NotNil(t, pairs) {
-			assert.Equal(t, len(pairs), 2)
-		}
-
-		// Check pairs, those are not necessarily in Put order
-		for _, pair := range pairs {
-			if pair.Key == firstKey {
-				assert.Equal(t, pair.Value, firstValue)
-			}
-			if pair.Key == secondKey {
-				assert.Equal(t, pair.Value, secondValue)
-			}
-		}
-	}
-
-	// List should fail: the key does not exist
-	pairs, err := kv.List("idontexist")
-	assert.Equal(t, store.ErrKeyNotFound, err)
-	assert.Nil(t, pairs)
-}
-
-func testDeleteTree(t *testing.T, kv store.Store) {
-	prefix := "testDeleteTree"
-
-	firstKey := "testDeleteTree/first"
-	firstValue := []byte("first")
-
-	secondKey := "testDeleteTree/second"
-	secondValue := []byte("second")
-
-	// Put the first key
-	err := kv.Put(firstKey, firstValue, nil)
-	assert.NoError(t, err)
-
-	// Put the second key
-	err = kv.Put(secondKey, secondValue, nil)
-	assert.NoError(t, err)
-
-	// Get should work on the first Key
-	pair, err := kv.Get(firstKey)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, firstValue)
-	assert.NotEqual(t, pair.LastIndex, 0)
-
-	// Get should work on the second Key
-	pair, err = kv.Get(secondKey)
-	assert.NoError(t, err)
-	if assert.NotNil(t, pair) {
-		assert.NotNil(t, pair.Value)
-	}
-	assert.Equal(t, pair.Value, secondValue)
-	assert.NotEqual(t, pair.LastIndex, 0)
-
-	// Delete Values under directory `nodes`
-	err = kv.DeleteTree(prefix)
-	assert.NoError(t, err)
-
-	// Get should fail on both keys
-	pair, err = kv.Get(firstKey)
-	assert.Error(t, err)
-	assert.Nil(t, pair)
-
-	pair, err = kv.Get(secondKey)
-	assert.Error(t, err)
-	assert.Nil(t, pair)
-}
-
-// RunCleanup cleans up keys introduced by the tests
-func RunCleanup(t *testing.T, kv store.Store) {
-	for _, key := range []string{
-		"testAtomicPutWithSlashSuffixKey",
-		"testPutGetDeleteExists",
-		"testWatch",
-		"testWatchTree",
-		"testAtomicPut",
-		"testAtomicPutCreate",
-		"testAtomicDelete",
-		"testLockUnlock",
-		"testLockTTL",
-		"testPutTTL",
-		"testList",
-		"testDeleteTree",
-	} {
-		err := kv.DeleteTree(key)
-		assert.True(t, err == nil || err == store.ErrKeyNotFound, fmt.Sprintf("failed to delete tree key %s: %v", key, err))
-		err = kv.Delete(key)
-		assert.True(t, err == nil || err == store.ErrKeyNotFound, fmt.Sprintf("failed to delete key %s: %v", key, err))
-	}
-}