func TestCanManageReposIndependently(t *testing.T) {
t.Parallel()
pathA := testRepoPath("a", t)
pathB := testRepoPath("b", t)
t.Log("initialize two repos")
assert.Nil(Init(pathA, &config.Config{}), t, "a", "should initialize successfully")
assert.Nil(Init(pathB, &config.Config{}), t, "b", "should initialize successfully")
t.Log("ensure repos initialized")
assert.True(IsInitialized(pathA), t, "a should be initialized")
assert.True(IsInitialized(pathB), t, "b should be initialized")
t.Log("open the two repos")
repoA, err := Open(pathA)
assert.Nil(err, t, "a")
repoB, err := Open(pathB)
assert.Nil(err, t, "b")
t.Log("close and remove b while a is open")
assert.Nil(repoB.Close(), t, "close b")
assert.Nil(Remove(pathB), t, "remove b")
t.Log("close and remove a")
assert.Nil(repoA.Close(), t)
assert.Nil(Remove(pathA), t)
}
func TestInitIdempotence(t *testing.T) {
t.Parallel()
path := testRepoPath("", t)
for i := 0; i < 10; i++ {
assert.Nil(Init(path, &config.Config{}), t, "multiple calls to init should succeed")
}
}
func TestOpenMoreThanOnceInSameProcess(t *testing.T) {
t.Parallel()
path := testRepoPath("", t)
assert.Nil(Init(path, &config.Config{}), t)
r1, err := Open(path)
assert.Nil(err, t, "first repo should open successfully")
r2, err := Open(path)
assert.Nil(err, t, "second repo should open successfully")
assert.True(r1 == r2, t, "second open returns same value")
assert.Nil(r1.Close(), t)
assert.Nil(r2.Close(), t)
}
func TestDatastoreGetNotAllowedAfterClose(t *testing.T) {
t.Parallel()
path := testRepoPath("test", t)
assert.True(!IsInitialized(path), t, "should NOT be initialized")
assert.Nil(Init(path, &config.Config{}), t, "should initialize successfully")
r, err := Open(path)
assert.Nil(err, t, "should open successfully")
k := "key"
data := []byte(k)
assert.Nil(r.Datastore().Put(datastore.NewKey(k), data), t, "Put should be successful")
assert.Nil(r.Close(), t)
_, err = r.Datastore().Get(datastore.NewKey(k))
assert.Err(err, t, "after closer, Get should be fail")
}
func TestDelete(t *testing.T) {
client := clientOrAbort(t)
ds, err := NewDatastore(client)
if err != nil {
t.Fatal(err)
}
key, val := datastore.NewKey("foo"), []byte("bar")
assert.Nil(ds.Put(key, val), t)
assert.Nil(ds.Delete(key), t)
hasAfterDelete, err := ds.Has(key)
if err != nil {
t.Fatal(err)
}
if hasAfterDelete {
t.Fail()
}
}
func TestExpiry(t *testing.T) {
ttl := 1 * time.Second
client := clientOrAbort(t)
ds, err := NewExpiringDatastore(client, ttl)
if err != nil {
t.Fatal(err)
}
key, val := datastore.NewKey("foo"), []byte("bar")
assert.Nil(ds.Put(key, val), t)
time.Sleep(ttl + 1*time.Second)
assert.Nil(ds.Delete(key), t)
hasAfterExpiration, err := ds.Has(key)
if err != nil {
t.Fatal(err)
}
if hasAfterExpiration {
t.Fail()
}
}
func TestPutGetBytes(t *testing.T) {
client := clientOrAbort(t)
ds, err := NewDatastore(client)
if err != nil {
t.Fatal(err)
}
key, val := datastore.NewKey("foo"), []byte("bar")
assert.Nil(ds.Put(key, val), t)
v, err := ds.Get(key)
if err != nil {
t.Fatal(err)
}
if bytes.Compare(v.([]byte), val) != 0 {
t.Fail()
}
}
func TestDatastorePersistsFromRepoToRepo(t *testing.T) {
t.Parallel()
path := testRepoPath("test", t)
assert.Nil(Init(path, &config.Config{}), t)
r1, err := Open(path)
assert.Nil(err, t)
k := "key"
expected := []byte(k)
assert.Nil(r1.Datastore().Put(datastore.NewKey(k), expected), t, "using first repo, Put should be successful")
assert.Nil(r1.Close(), t)
r2, err := Open(path)
assert.Nil(err, t)
v, err := r2.Datastore().Get(datastore.NewKey(k))
assert.Nil(err, t, "using second repo, Get should be successful")
actual, ok := v.([]byte)
assert.True(ok, t, "value should be the []byte from r1's Put")
assert.Nil(r2.Close(), t)
assert.True(bytes.Compare(expected, actual) == 0, t, "data should match")
}
func TestRemove(t *testing.T) {
t.Parallel()
path := testRepoPath("foo", t)
assert.Nil(Remove(path), t, "can remove a repository")
}