services/internal/fs/simplestore_test.go - release.go.x.ref - Git at Google

 // Copyright 2015 The Vanadium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 package fs_test

 import (
 	"encoding/gob"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"reflect"
 	"testing"

 	"v.io/v23/naming"
 	"v.io/v23/services/application"
 	"v.io/v23/verror"
 	"v.io/x/ref/services/internal/fs"
 	_ "v.io/x/ref/services/profile"
 )

 func tempFile(t *testing.T) string {
 	tmpfile, err := ioutil.TempFile("", "simplestore-test-")
 	if err != nil {
 		t.Fatalf("ioutil.TempFile() failed: %v", err)
 	}
 	defer tmpfile.Close()
 	return tmpfile.Name()
 }

 func TestNewMemstore(t *testing.T) {
 	memstore, err := fs.NewMemstore("")

 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}

 	if _, err = os.Stat(memstore.PersistedFile()); err != nil {
 		t.Fatalf("Stat(%v) failed: %v", memstore.PersistedFile(), err)
 	}
 	os.Remove(memstore.PersistedFile())
 }

 func TestNewNamedMemstore(t *testing.T) {
 	path := tempFile(t)
 	defer os.Remove(path)
 	memstore, err := fs.NewMemstore(path)
 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}

 	if _, err = os.Stat(memstore.PersistedFile()); err != nil {
 		t.Fatalf("Stat(%v) failed: %v", path, err)
 	}
 }

 // Verify that all of the listed paths Exists().
 // Caller is responsible for setting up any transaction state necessary.
 func allPathsExist(ts *fs.Memstore, paths []string) error {
 	for _, p := range paths {
 		exists, err := ts.BindObject(p).Exists(nil)
 		if err != nil {
 			return fmt.Errorf("Exists(%s) expected to succeed but failed: %v", p, err)
 		}
 		if !exists {
 			return fmt.Errorf("Exists(%s) expected to be true but is false", p)
 		}
 	}
 	return nil
 }

 // Verify that all of the listed paths !Exists().
 // Caller is responsible for setting up any transaction state necessary.
 func allPathsDontExist(ts *fs.Memstore, paths []string) error {
 	for _, p := range paths {
 		exists, err := ts.BindObject(p).Exists(nil)
 		if err != nil {
 			return fmt.Errorf("Exists(%s) expected to succeed but failed: %v", p, err)
 		}
 		if exists {
 			return fmt.Errorf("Exists(%s) expected to be false but is true", p)
 		}
 	}
 	return nil
 }

 type PathValue struct {
 	Path     string
 	Expected interface{}
 }

 // getEquals tests that every provided path is equal to the specified value.
 func allPathsEqual(ts *fs.Memstore, pvs []PathValue) error {
 	for _, p := range pvs {
 		v, err := ts.BindObject(p.Path).Get(nil)
 		if err != nil {
 			return fmt.Errorf("Get(%s) expected to succeed but failed: %v", p, err)
 		}
 		if !reflect.DeepEqual(p.Expected, v.Value) {
 			return fmt.Errorf("Unexpected non-equality for %s: got %v, expected %v", p.Path, v.Value, p.Expected)
 		}
 	}
 	return nil
 }

 func TestSerializeDeserialize(t *testing.T) {
 	path := tempFile(t)
 	defer os.Remove(path)
 	memstoreOriginal, err := fs.NewMemstore(path)
 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}

 	// Create example data.
 	envelope := application.Envelope{
 		Args:   []string{"--help"},
 		Env:    []string{"DEBUG=1"},
 		Binary: application.SignedFile{File: "/v23/name/of/binary"},
 	}
 	secondEnvelope := application.Envelope{
 		Args:   []string{"--save"},
 		Env:    []string{"VEYRON=42"},
 		Binary: application.SignedFile{File: "/v23/name/of/binary/is/memstored"},
 	}

 	// TRANSACTION BEGIN
 	// Insert a value into the fs.Memstore at /test/a
 	memstoreOriginal.Lock()
 	tname, err := memstoreOriginal.BindTransactionRoot("ignored").CreateTransaction(nil)
 	if err != nil {
 		t.Fatalf("CreateTransaction() failed: %v", err)
 	}
 	if _, err := memstoreOriginal.BindObject(fs.TP("/test/a")).Put(nil, envelope); err != nil {
 		t.Fatalf("Put() failed: %v", err)
 	}

 	if err := allPathsExist(memstoreOriginal, []string{fs.TP("/test/a"), fs.TP("/test")}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreOriginal, []PathValue{{fs.TP("/test/a"), envelope}}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	if err := memstoreOriginal.BindTransaction(tname).Commit(nil); err != nil {
 		t.Fatalf("Commit() failed: %v", err)
 	}
 	memstoreOriginal.Unlock()
 	// TRANSACTION END

 	// Validate persisted state.
 	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test"}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreOriginal, []PathValue{{"/test/a", envelope}}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	// TRANSACTION BEGIN Write a value to /test/b as well.
 	memstoreOriginal.Lock()
 	tname, err = memstoreOriginal.BindTransactionRoot("also ignored").CreateTransaction(nil)
 	bindingTnameTestB := memstoreOriginal.BindObject(fs.TP("/test/b"))
 	if _, err := bindingTnameTestB.Put(nil, envelope); err != nil {
 		t.Fatalf("Put() failed: %v", err)
 	}

 	// Validate persisted state during transaction
 	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test"}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreOriginal, []PathValue{{"/test/a", envelope}}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	// Validate pending state during transaction
 	if err := allPathsExist(memstoreOriginal, []string{fs.TP("/test/a"), fs.TP("/test"), fs.TP("/test/b")}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreOriginal, []PathValue{
 		{fs.TP("/test/a"), envelope},
 		{fs.TP("/test/b"), envelope}}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	// Commit the <tname>/test/b to /test/b
 	if err := memstoreOriginal.Commit(nil); err != nil {
 		t.Fatalf("Commit() failed: %v", err)
 	}
 	memstoreOriginal.Unlock()
 	// TODO(rjkroege): Consider ensuring that Get() on  <tname>/test/b should now fail.
 	// TRANSACTION END

 	// Validate persisted state after transaction
 	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test", "/test/b"}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreOriginal, []PathValue{
 		{"/test/a", envelope},
 		{"/test/b", envelope}}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	// TRANSACTION BEGIN (to be abandonned)
 	memstoreOriginal.Lock()
 	tname, err = memstoreOriginal.BindTransactionRoot("").CreateTransaction(nil)

 	// Exists is true before doing anything.
 	if err := allPathsExist(memstoreOriginal, []string{fs.TP("/test")}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	if _, err := memstoreOriginal.BindObject(fs.TP("/test/b")).Put(nil, secondEnvelope); err != nil {
 		t.Fatalf("Put() failed: %v", err)
 	}

 	// Validate persisted state during transaction
 	if err := allPathsExist(memstoreOriginal, []string{
 		"/test/a",
 		"/test/b",
 		"/test",
 		fs.TP("/test"),
 		fs.TP("/test/a"),
 		fs.TP("/test/b"),
 	}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreOriginal, []PathValue{
 		{"/test/a", envelope},
 		{"/test/b", envelope},
 		{fs.TP("/test/b"), secondEnvelope},
 		{fs.TP("/test/a"), envelope},
 	}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	// Pending Remove() of /test
 	if err := memstoreOriginal.BindObject(fs.TP("/test")).Remove(nil); err != nil {
 		t.Fatalf("Remove() failed: %v", err)
 	}

 	// Verify that all paths are successfully removed from the in-progress transaction.
 	if err := allPathsDontExist(memstoreOriginal, []string{fs.TP("/test/a"), fs.TP("/test"), fs.TP("/test/b")}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	// But all paths remain in the persisted version.
 	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test", "/test/b"}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreOriginal, []PathValue{
 		{"/test/a", envelope},
 		{"/test/b", envelope},
 	}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	// At which point, Get() on the transaction won't find anything.
 	if _, err := memstoreOriginal.BindObject(fs.TP("/test/a")).Get(nil); verror.ErrorID(err) != fs.ErrNotInMemStore.ID {
 		t.Fatalf("Get() should have failed: got %v, expected %v", err, verror.New(fs.ErrNotInMemStore, nil, tname+"/test/a"))
 	}

 	// Attempting to Remove() it over again will fail.
 	if err := memstoreOriginal.BindObject(fs.TP("/test/a")).Remove(nil); verror.ErrorID(err) != fs.ErrNotInMemStore.ID {
 		t.Fatalf("Remove() should have failed: got %v, expected %v", err, verror.New(fs.ErrNotInMemStore, nil, tname+"/test/a"))
 	}

 	// Attempting to Remove() a non-existing path will fail.
 	if err := memstoreOriginal.BindObject(fs.TP("/foo")).Remove(nil); verror.ErrorID(err) != fs.ErrNotInMemStore.ID {
 		t.Fatalf("Remove() should have failed: got %v, expected %v", err, verror.New(fs.ErrNotInMemStore, nil, tname+"/foo"))
 	}

 	// Exists() a non-existing path will fail.
 	if present, _ := memstoreOriginal.BindObject(fs.TP("/foo")).Exists(nil); present {
 		t.Fatalf("Exists() should have failed for non-existing path %s", tname+"/foo")
 	}

 	// Abort the transaction without committing it.
 	memstoreOriginal.Abort(nil)
 	memstoreOriginal.Unlock()
 	// TRANSACTION END (ABORTED)

 	// Validate that persisted state after abandonned transaction has not changed.
 	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test", "/test/b"}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreOriginal, []PathValue{
 		{"/test/a", envelope},
 		{"/test/b", envelope}}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	// Validate that Get will fail on a non-existent path.
 	if _, err := memstoreOriginal.BindObject("/test/c").Get(nil); verror.ErrorID(err) != fs.ErrNotInMemStore.ID {
 		t.Fatalf("Get() should have failed: got %v, expected %v", err, verror.New(fs.ErrNotInMemStore, nil, tname+"/test/c"))
 	}

 	// Verify that the previous Commit() operations have persisted to
 	// disk by creating a new Memstore from the contents on disk.
 	memstoreCopy, err := fs.NewMemstore(path)
 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}
 	// Verify that memstoreCopy is an exact copy of memstoreOriginal.
 	if err := allPathsExist(memstoreCopy, []string{"/test/a", "/test", "/test/b"}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreCopy, []PathValue{
 		{"/test/a", envelope},
 		{"/test/b", envelope}}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	// TRANSACTION BEGIN
 	memstoreCopy.Lock()
 	tname, err = memstoreCopy.BindTransactionRoot("also ignored").CreateTransaction(nil)

 	// Add a pending object c to test that pending objects are deleted.
 	if _, err := memstoreCopy.BindObject(fs.TP("/test/c")).Put(nil, secondEnvelope); err != nil {
 		t.Fatalf("Put() failed: %v", err)
 	}
 	if err := allPathsExist(memstoreCopy, []string{
 		fs.TP("/test/a"),
 		"/test/a",
 		fs.TP("/test"),
 		"/test",
 		fs.TP("/test/b"),
 		"/test/b",
 		fs.TP("/test/c"),
 	}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsEqual(memstoreCopy, []PathValue{
 		{fs.TP("/test/a"), envelope},
 		{fs.TP("/test/b"), envelope},
 		{fs.TP("/test/c"), secondEnvelope},
 		{"/test/a", envelope},
 		{"/test/b", envelope},
 	}); err != nil {
 		t.Fatalf("%v", err)
 	}

 	// Remove /test/a /test/b /test/c /test
 	if err := memstoreCopy.BindObject(fs.TP("/test")).Remove(nil); err != nil {
 		t.Fatalf("Remove() failed: %v", err)
 	}
 	// Verify that all paths are successfully removed from the in-progress transaction.
 	if err := allPathsDontExist(memstoreCopy, []string{
 		fs.TP("/test/a"),
 		fs.TP("/test"),
 		fs.TP("/test/b"),
 		fs.TP("/test/c"),
 	}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	if err := allPathsExist(memstoreCopy, []string{
 		"/test/a",
 		"/test",
 		"/test/b",
 	}); err != nil {
 		t.Fatalf("%v", err)
 	}
 	// Commit the change.
 	if err = memstoreCopy.Commit(nil); err != nil {
 		t.Fatalf("Commit() failed: %v", err)
 	}
 	memstoreCopy.Unlock()
 	// TRANSACTION END

 	// Create a new Memstore from file to see if Remove operates are
 	// persisted.
 	memstoreRemovedCopy, err := fs.NewMemstore(path)
 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed for removed copy: %v", err)
 	}
 	if err := allPathsDontExist(memstoreRemovedCopy, []string{
 		"/test/a",
 		"/test",
 		"/test/b",
 		"/test/c",
 	}); err != nil {
 		t.Fatalf("%v", err)
 	}
 }

 func TestOperationsNeedValidBinding(t *testing.T) {
 	path := tempFile(t)
 	defer os.Remove(path)
 	memstoreOriginal, err := fs.NewMemstore(path)
 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}

 	// Create example data.
 	envelope := application.Envelope{
 		Args:   []string{"--help"},
 		Env:    []string{"DEBUG=1"},
 		Binary: application.SignedFile{File: "/v23/name/of/binary"},
 	}

 	// TRANSACTION BEGIN
 	// Attempt inserting a value at /test/a.
 	memstoreOriginal.Lock()
 	tname, err := memstoreOriginal.BindTransactionRoot("").CreateTransaction(nil)
 	if err != nil {
 		t.Fatalf("CreateTransaction() failed: %v", err)
 	}

 	if err := memstoreOriginal.BindTransaction(tname).Commit(nil); err != nil {
 		t.Fatalf("Commit() failed: %v", err)
 	}
 	memstoreOriginal.Unlock()
 	// TRANSACTION END

 	// Put outside ot a transaction should fail.
 	bindingTnameTestA := memstoreOriginal.BindObject(naming.Join("fooey", "/test/a"))
 	if _, err := bindingTnameTestA.Put(nil, envelope); verror.ErrorID(err) != fs.ErrWithoutTransaction.ID {
 		t.Fatalf("Put() failed: got %v, expected %v", err, verror.New(fs.ErrWithoutTransaction, nil, "Put()"))
 	}

 	// Remove outside of a transaction should fail
 	if err := bindingTnameTestA.Remove(nil); verror.ErrorID(err) != fs.ErrWithoutTransaction.ID {
 		t.Fatalf("Put() failed: got %v, expected %v", err, verror.New(fs.ErrWithoutTransaction, nil, "Remove()"))
 	}

 	// Commit outside of a transaction should fail
 	if err := memstoreOriginal.BindTransaction(tname).Commit(nil); verror.ErrorID(err) != fs.ErrDoubleCommit.ID {
 		t.Fatalf("Commit() failed: got %v, expected %v", err, verror.New(fs.ErrDoubleCommit, nil))
 	}

 	// Attempt inserting a value at /test/b
 	memstoreOriginal.Lock()
 	tname, err = memstoreOriginal.BindTransactionRoot("").CreateTransaction(nil)
 	if err != nil {
 		t.Fatalf("CreateTransaction() failed: %v", err)
 	}

 	bindingTnameTestB := memstoreOriginal.BindObject(fs.TP("/test/b"))
 	if _, err := bindingTnameTestB.Put(nil, envelope); err != nil {
 		t.Fatalf("Put() failed: %v", err)
 	}
 	// Abandon transaction.
 	memstoreOriginal.Unlock()

 	// Remove should definitely fail on an abndonned transaction.
 	if err := bindingTnameTestB.Remove(nil); verror.ErrorID(err) != fs.ErrWithoutTransaction.ID {
 		t.Fatalf("Remove() failed: got %v, expected %v", err, verror.New(fs.ErrWithoutTransaction, nil, "Remove()"))
 	}
 }

 func TestOpenEmptyMemstore(t *testing.T) {
 	path := tempFile(t)
 	defer os.Remove(path)

 	// Create a brand new memstore persisted to namedms. This will
 	// have the side-effect of creating an empty backing file.
 	if _, err := fs.NewMemstore(path); err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}

 	// Create another memstore that will attempt to deserialize the empty
 	// backing file.
 	if _, err := fs.NewMemstore(path); err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}
 }

 func TestChildren(t *testing.T) {
 	memstore, err := fs.NewMemstore("")
 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}
 	defer os.Remove(memstore.PersistedFile())

 	// Create example data.
 	envelope := application.Envelope{
 		Args:   []string{"--help"},
 		Env:    []string{"DEBUG=1"},
 		Binary: application.SignedFile{File: "/v23/name/of/binary"},
 	}

 	// TRANSACTION BEGIN
 	memstore.Lock()
 	tname, err := memstore.BindTransactionRoot("ignored").CreateTransaction(nil)
 	if err != nil {
 		t.Fatalf("CreateTransaction() failed: %v", err)
 	}
 	// Insert a few values
 	names := []string{"/test/a", "/test/b", "/test/a/x", "/test/a/y", "/test/b/fooooo/bar"}
 	for _, n := range names {
 		if _, err := memstore.BindObject(fs.TP(n)).Put(nil, envelope); err != nil {
 			t.Fatalf("Put() failed: %v", err)
 		}
 	}
 	if err := memstore.BindTransaction(tname).Commit(nil); err != nil {
 		t.Fatalf("Commit() failed: %v", err)
 	}
 	memstore.Unlock()
 	// TRANSACTION END

 	memstore.Lock()
 	testcases := []struct {
 		name     string
 		children []string
 	}{
 		{"/", []string{"test"}},
 		{"/test", []string{"a", "b"}},
 		{"/test/a", []string{"x", "y"}},
 		{"/test/b", []string{"fooooo"}},
 		{"/test/b/fooooo", []string{"bar"}},
 		{"/test/a/x", nil},
 		{"/test/a/y", nil},
 	}
 	for _, tc := range testcases {
 		children, err := memstore.BindObject(tc.name).Children()
 		if err != nil {
 			t.Errorf("unexpected error for %q: %v", tc.name, err)
 			continue
 		}
 		if !reflect.DeepEqual(children, tc.children) {
 			t.Errorf("unexpected result for %q: got %q, expected %q", tc.name, children, tc.children)
 		}
 	}

 	for _, notthere := range []string{"/doesnt-exist", "/tes"} {
 		if _, err := memstore.BindObject(notthere).Children(); err == nil {
 			t.Errorf("unexpected success for: %q", notthere)
 		}
 	}
 	memstore.Unlock()
 }

 func TestFormatConversion(t *testing.T) {
 	path := tempFile(t)
 	defer os.Remove(path)
 	originalMemstore, err := fs.NewMemstore(path)
 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}

 	// Create example data.
 	envelope := application.Envelope{
 		Args:   []string{"--help"},
 		Env:    []string{"DEBUG=1"},
 		Binary: application.SignedFile{File: "/v23/name/of/binary"},
 	}

 	// TRANSACTION BEGIN
 	// Insert a value into the legacy Memstore at /test/a
 	originalMemstore.Lock()
 	tname, err := originalMemstore.BindTransactionRoot("ignored").CreateTransaction(nil)
 	if err != nil {
 		t.Fatalf("CreateTransaction() failed: %v", err)
 	}
 	if _, err := originalMemstore.BindObject(fs.TP("/test/a")).Put(nil, envelope); err != nil {
 		t.Fatalf("Put() failed: %v", err)
 	}
 	if err := originalMemstore.BindTransaction(tname).Commit(nil); err != nil {
 		t.Fatalf("Commit() failed: %v", err)
 	}
 	originalMemstore.Unlock()

 	// Write the original memstore to a GOB file.
 	if err := gobPersist(t, originalMemstore); err != nil {
 		t.Fatalf("gobPersist() failed: %v", err)
 	}

 	// Open the GOB format file.
 	memstore, err := fs.NewMemstore(path)
 	if err != nil {
 		t.Fatalf("fs.NewMemstore() failed: %v", err)
 	}

 	// Verify the state.
 	if err := allPathsEqual(memstore, []PathValue{{"/test/a", envelope}}); err != nil {
 		t.Fatalf("%v", err)
 	}
 }

 // gobPersist writes Memstore ms to its backing file.
 func gobPersist(t *testing.T, ms *fs.Memstore) error {
 	// Convert this memstore to the legacy GOM format.
 	data := ms.GetGOBConvertedMemstore()

 	// Persist this file to a GOB format file.
 	fname := ms.PersistedFile()
 	file, err := os.Create(fname)
 	if err != nil {
 		t.Fatalf("os.Create(%s) failed: %v", fname, err)
 	}
 	defer file.Close()

 	enc := gob.NewEncoder(file)
 	err = enc.Encode(data)
 	if err := enc.Encode(data); err != nil {
 		t.Fatalf("enc.Encode() failed: %v", err)
 	}
 	return nil
 }
	// Copyright 2015 The Vanadium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	package fs_test

	import (
	"encoding/gob"
	"fmt"
	"io/ioutil"
	"os"
	"reflect"
	"testing"

	"v.io/v23/naming"
	"v.io/v23/services/application"
	"v.io/v23/verror"
	"v.io/x/ref/services/internal/fs"
	_ "v.io/x/ref/services/profile"
	)

	func tempFile(t *testing.T) string {
	tmpfile, err := ioutil.TempFile("", "simplestore-test-")
	if err != nil {
	t.Fatalf("ioutil.TempFile() failed: %v", err)
	}
	defer tmpfile.Close()
	return tmpfile.Name()
	}

	func TestNewMemstore(t *testing.T) {
	memstore, err := fs.NewMemstore("")

	if err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}

	if _, err = os.Stat(memstore.PersistedFile()); err != nil {
	t.Fatalf("Stat(%v) failed: %v", memstore.PersistedFile(), err)
	}
	os.Remove(memstore.PersistedFile())
	}

	func TestNewNamedMemstore(t *testing.T) {
	path := tempFile(t)
	defer os.Remove(path)
	memstore, err := fs.NewMemstore(path)
	if err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}

	if _, err = os.Stat(memstore.PersistedFile()); err != nil {
	t.Fatalf("Stat(%v) failed: %v", path, err)
	}
	}

	// Verify that all of the listed paths Exists().
	// Caller is responsible for setting up any transaction state necessary.
	func allPathsExist(ts *fs.Memstore, paths []string) error {
	for _, p := range paths {
	exists, err := ts.BindObject(p).Exists(nil)
	if err != nil {
	return fmt.Errorf("Exists(%s) expected to succeed but failed: %v", p, err)
	}
	if !exists {
	return fmt.Errorf("Exists(%s) expected to be true but is false", p)
	}
	}
	return nil
	}

	// Verify that all of the listed paths !Exists().
	// Caller is responsible for setting up any transaction state necessary.
	func allPathsDontExist(ts *fs.Memstore, paths []string) error {
	for _, p := range paths {
	exists, err := ts.BindObject(p).Exists(nil)
	if err != nil {
	return fmt.Errorf("Exists(%s) expected to succeed but failed: %v", p, err)
	}
	if exists {
	return fmt.Errorf("Exists(%s) expected to be false but is true", p)
	}
	}
	return nil
	}

	type PathValue struct {
	Path string
	Expected interface{}
	}

	// getEquals tests that every provided path is equal to the specified value.
	func allPathsEqual(ts *fs.Memstore, pvs []PathValue) error {
	for _, p := range pvs {
	v, err := ts.BindObject(p.Path).Get(nil)
	if err != nil {
	return fmt.Errorf("Get(%s) expected to succeed but failed: %v", p, err)
	}
	if !reflect.DeepEqual(p.Expected, v.Value) {
	return fmt.Errorf("Unexpected non-equality for %s: got %v, expected %v", p.Path, v.Value, p.Expected)
	}
	}
	return nil
	}

	func TestSerializeDeserialize(t *testing.T) {
	path := tempFile(t)
	defer os.Remove(path)
	memstoreOriginal, err := fs.NewMemstore(path)
	if err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}

	// Create example data.
	envelope := application.Envelope{
	Args: []string{"--help"},
	Env: []string{"DEBUG=1"},
	Binary: application.SignedFile{File: "/v23/name/of/binary"},
	}
	secondEnvelope := application.Envelope{
	Args: []string{"--save"},
	Env: []string{"VEYRON=42"},
	Binary: application.SignedFile{File: "/v23/name/of/binary/is/memstored"},
	}

	// TRANSACTION BEGIN
	// Insert a value into the fs.Memstore at /test/a
	memstoreOriginal.Lock()
	tname, err := memstoreOriginal.BindTransactionRoot("ignored").CreateTransaction(nil)
	if err != nil {
	t.Fatalf("CreateTransaction() failed: %v", err)
	}
	if _, err := memstoreOriginal.BindObject(fs.TP("/test/a")).Put(nil, envelope); err != nil {
	t.Fatalf("Put() failed: %v", err)
	}

	if err := allPathsExist(memstoreOriginal, []string{fs.TP("/test/a"), fs.TP("/test")}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreOriginal, []PathValue{{fs.TP("/test/a"), envelope}}); err != nil {
	t.Fatalf("%v", err)
	}

	if err := memstoreOriginal.BindTransaction(tname).Commit(nil); err != nil {
	t.Fatalf("Commit() failed: %v", err)
	}
	memstoreOriginal.Unlock()
	// TRANSACTION END

	// Validate persisted state.
	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test"}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreOriginal, []PathValue{{"/test/a", envelope}}); err != nil {
	t.Fatalf("%v", err)
	}

	// TRANSACTION BEGIN Write a value to /test/b as well.
	memstoreOriginal.Lock()
	tname, err = memstoreOriginal.BindTransactionRoot("also ignored").CreateTransaction(nil)
	bindingTnameTestB := memstoreOriginal.BindObject(fs.TP("/test/b"))
	if _, err := bindingTnameTestB.Put(nil, envelope); err != nil {
	t.Fatalf("Put() failed: %v", err)
	}

	// Validate persisted state during transaction
	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test"}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreOriginal, []PathValue{{"/test/a", envelope}}); err != nil {
	t.Fatalf("%v", err)
	}
	// Validate pending state during transaction
	if err := allPathsExist(memstoreOriginal, []string{fs.TP("/test/a"), fs.TP("/test"), fs.TP("/test/b")}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreOriginal, []PathValue{
	{fs.TP("/test/a"), envelope},
	{fs.TP("/test/b"), envelope}}); err != nil {
	t.Fatalf("%v", err)
	}

	// Commit the <tname>/test/b to /test/b
	if err := memstoreOriginal.Commit(nil); err != nil {
	t.Fatalf("Commit() failed: %v", err)
	}
	memstoreOriginal.Unlock()
	// TODO(rjkroege): Consider ensuring that Get() on <tname>/test/b should now fail.
	// TRANSACTION END

	// Validate persisted state after transaction
	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test", "/test/b"}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreOriginal, []PathValue{
	{"/test/a", envelope},
	{"/test/b", envelope}}); err != nil {
	t.Fatalf("%v", err)
	}

	// TRANSACTION BEGIN (to be abandonned)
	memstoreOriginal.Lock()
	tname, err = memstoreOriginal.BindTransactionRoot("").CreateTransaction(nil)

	// Exists is true before doing anything.
	if err := allPathsExist(memstoreOriginal, []string{fs.TP("/test")}); err != nil {
	t.Fatalf("%v", err)
	}

	if _, err := memstoreOriginal.BindObject(fs.TP("/test/b")).Put(nil, secondEnvelope); err != nil {
	t.Fatalf("Put() failed: %v", err)
	}

	// Validate persisted state during transaction
	if err := allPathsExist(memstoreOriginal, []string{
	"/test/a",
	"/test/b",
	"/test",
	fs.TP("/test"),
	fs.TP("/test/a"),
	fs.TP("/test/b"),
	}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreOriginal, []PathValue{
	{"/test/a", envelope},
	{"/test/b", envelope},
	{fs.TP("/test/b"), secondEnvelope},
	{fs.TP("/test/a"), envelope},
	}); err != nil {
	t.Fatalf("%v", err)
	}

	// Pending Remove() of /test
	if err := memstoreOriginal.BindObject(fs.TP("/test")).Remove(nil); err != nil {
	t.Fatalf("Remove() failed: %v", err)
	}

	// Verify that all paths are successfully removed from the in-progress transaction.
	if err := allPathsDontExist(memstoreOriginal, []string{fs.TP("/test/a"), fs.TP("/test"), fs.TP("/test/b")}); err != nil {
	t.Fatalf("%v", err)
	}
	// But all paths remain in the persisted version.
	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test", "/test/b"}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreOriginal, []PathValue{
	{"/test/a", envelope},
	{"/test/b", envelope},
	}); err != nil {
	t.Fatalf("%v", err)
	}

	// At which point, Get() on the transaction won't find anything.
	if _, err := memstoreOriginal.BindObject(fs.TP("/test/a")).Get(nil); verror.ErrorID(err) != fs.ErrNotInMemStore.ID {
	t.Fatalf("Get() should have failed: got %v, expected %v", err, verror.New(fs.ErrNotInMemStore, nil, tname+"/test/a"))
	}

	// Attempting to Remove() it over again will fail.
	if err := memstoreOriginal.BindObject(fs.TP("/test/a")).Remove(nil); verror.ErrorID(err) != fs.ErrNotInMemStore.ID {
	t.Fatalf("Remove() should have failed: got %v, expected %v", err, verror.New(fs.ErrNotInMemStore, nil, tname+"/test/a"))
	}

	// Attempting to Remove() a non-existing path will fail.
	if err := memstoreOriginal.BindObject(fs.TP("/foo")).Remove(nil); verror.ErrorID(err) != fs.ErrNotInMemStore.ID {
	t.Fatalf("Remove() should have failed: got %v, expected %v", err, verror.New(fs.ErrNotInMemStore, nil, tname+"/foo"))
	}

	// Exists() a non-existing path will fail.
	if present, _ := memstoreOriginal.BindObject(fs.TP("/foo")).Exists(nil); present {
	t.Fatalf("Exists() should have failed for non-existing path %s", tname+"/foo")
	}

	// Abort the transaction without committing it.
	memstoreOriginal.Abort(nil)
	memstoreOriginal.Unlock()
	// TRANSACTION END (ABORTED)

	// Validate that persisted state after abandonned transaction has not changed.
	if err := allPathsExist(memstoreOriginal, []string{"/test/a", "/test", "/test/b"}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreOriginal, []PathValue{
	{"/test/a", envelope},
	{"/test/b", envelope}}); err != nil {
	t.Fatalf("%v", err)
	}

	// Validate that Get will fail on a non-existent path.
	if _, err := memstoreOriginal.BindObject("/test/c").Get(nil); verror.ErrorID(err) != fs.ErrNotInMemStore.ID {
	t.Fatalf("Get() should have failed: got %v, expected %v", err, verror.New(fs.ErrNotInMemStore, nil, tname+"/test/c"))
	}

	// Verify that the previous Commit() operations have persisted to
	// disk by creating a new Memstore from the contents on disk.
	memstoreCopy, err := fs.NewMemstore(path)
	if err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}
	// Verify that memstoreCopy is an exact copy of memstoreOriginal.
	if err := allPathsExist(memstoreCopy, []string{"/test/a", "/test", "/test/b"}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreCopy, []PathValue{
	{"/test/a", envelope},
	{"/test/b", envelope}}); err != nil {
	t.Fatalf("%v", err)
	}

	// TRANSACTION BEGIN
	memstoreCopy.Lock()
	tname, err = memstoreCopy.BindTransactionRoot("also ignored").CreateTransaction(nil)

	// Add a pending object c to test that pending objects are deleted.
	if _, err := memstoreCopy.BindObject(fs.TP("/test/c")).Put(nil, secondEnvelope); err != nil {
	t.Fatalf("Put() failed: %v", err)
	}
	if err := allPathsExist(memstoreCopy, []string{
	fs.TP("/test/a"),
	"/test/a",
	fs.TP("/test"),
	"/test",
	fs.TP("/test/b"),
	"/test/b",
	fs.TP("/test/c"),
	}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsEqual(memstoreCopy, []PathValue{
	{fs.TP("/test/a"), envelope},
	{fs.TP("/test/b"), envelope},
	{fs.TP("/test/c"), secondEnvelope},
	{"/test/a", envelope},
	{"/test/b", envelope},
	}); err != nil {
	t.Fatalf("%v", err)
	}

	// Remove /test/a /test/b /test/c /test
	if err := memstoreCopy.BindObject(fs.TP("/test")).Remove(nil); err != nil {
	t.Fatalf("Remove() failed: %v", err)
	}
	// Verify that all paths are successfully removed from the in-progress transaction.
	if err := allPathsDontExist(memstoreCopy, []string{
	fs.TP("/test/a"),
	fs.TP("/test"),
	fs.TP("/test/b"),
	fs.TP("/test/c"),
	}); err != nil {
	t.Fatalf("%v", err)
	}
	if err := allPathsExist(memstoreCopy, []string{
	"/test/a",
	"/test",
	"/test/b",
	}); err != nil {
	t.Fatalf("%v", err)
	}
	// Commit the change.
	if err = memstoreCopy.Commit(nil); err != nil {
	t.Fatalf("Commit() failed: %v", err)
	}
	memstoreCopy.Unlock()
	// TRANSACTION END

	// Create a new Memstore from file to see if Remove operates are
	// persisted.
	memstoreRemovedCopy, err := fs.NewMemstore(path)
	if err != nil {
	t.Fatalf("fs.NewMemstore() failed for removed copy: %v", err)
	}
	if err := allPathsDontExist(memstoreRemovedCopy, []string{
	"/test/a",
	"/test",
	"/test/b",
	"/test/c",
	}); err != nil {
	t.Fatalf("%v", err)
	}
	}

	func TestOperationsNeedValidBinding(t *testing.T) {
	path := tempFile(t)
	defer os.Remove(path)
	memstoreOriginal, err := fs.NewMemstore(path)
	if err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}

	// Create example data.
	envelope := application.Envelope{
	Args: []string{"--help"},
	Env: []string{"DEBUG=1"},
	Binary: application.SignedFile{File: "/v23/name/of/binary"},
	}

	// TRANSACTION BEGIN
	// Attempt inserting a value at /test/a.
	memstoreOriginal.Lock()
	tname, err := memstoreOriginal.BindTransactionRoot("").CreateTransaction(nil)
	if err != nil {
	t.Fatalf("CreateTransaction() failed: %v", err)
	}

	if err := memstoreOriginal.BindTransaction(tname).Commit(nil); err != nil {
	t.Fatalf("Commit() failed: %v", err)
	}
	memstoreOriginal.Unlock()
	// TRANSACTION END

	// Put outside ot a transaction should fail.
	bindingTnameTestA := memstoreOriginal.BindObject(naming.Join("fooey", "/test/a"))
	if _, err := bindingTnameTestA.Put(nil, envelope); verror.ErrorID(err) != fs.ErrWithoutTransaction.ID {
	t.Fatalf("Put() failed: got %v, expected %v", err, verror.New(fs.ErrWithoutTransaction, nil, "Put()"))
	}

	// Remove outside of a transaction should fail
	if err := bindingTnameTestA.Remove(nil); verror.ErrorID(err) != fs.ErrWithoutTransaction.ID {
	t.Fatalf("Put() failed: got %v, expected %v", err, verror.New(fs.ErrWithoutTransaction, nil, "Remove()"))
	}

	// Commit outside of a transaction should fail
	if err := memstoreOriginal.BindTransaction(tname).Commit(nil); verror.ErrorID(err) != fs.ErrDoubleCommit.ID {
	t.Fatalf("Commit() failed: got %v, expected %v", err, verror.New(fs.ErrDoubleCommit, nil))
	}

	// Attempt inserting a value at /test/b
	memstoreOriginal.Lock()
	tname, err = memstoreOriginal.BindTransactionRoot("").CreateTransaction(nil)
	if err != nil {
	t.Fatalf("CreateTransaction() failed: %v", err)
	}

	bindingTnameTestB := memstoreOriginal.BindObject(fs.TP("/test/b"))
	if _, err := bindingTnameTestB.Put(nil, envelope); err != nil {
	t.Fatalf("Put() failed: %v", err)
	}
	// Abandon transaction.
	memstoreOriginal.Unlock()

	// Remove should definitely fail on an abndonned transaction.
	if err := bindingTnameTestB.Remove(nil); verror.ErrorID(err) != fs.ErrWithoutTransaction.ID {
	t.Fatalf("Remove() failed: got %v, expected %v", err, verror.New(fs.ErrWithoutTransaction, nil, "Remove()"))
	}
	}

	func TestOpenEmptyMemstore(t *testing.T) {
	path := tempFile(t)
	defer os.Remove(path)

	// Create a brand new memstore persisted to namedms. This will
	// have the side-effect of creating an empty backing file.
	if _, err := fs.NewMemstore(path); err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}

	// Create another memstore that will attempt to deserialize the empty
	// backing file.
	if _, err := fs.NewMemstore(path); err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}
	}

	func TestChildren(t *testing.T) {
	memstore, err := fs.NewMemstore("")
	if err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}
	defer os.Remove(memstore.PersistedFile())

	// Create example data.
	envelope := application.Envelope{
	Args: []string{"--help"},
	Env: []string{"DEBUG=1"},
	Binary: application.SignedFile{File: "/v23/name/of/binary"},
	}

	// TRANSACTION BEGIN
	memstore.Lock()
	tname, err := memstore.BindTransactionRoot("ignored").CreateTransaction(nil)
	if err != nil {
	t.Fatalf("CreateTransaction() failed: %v", err)
	}
	// Insert a few values
	names := []string{"/test/a", "/test/b", "/test/a/x", "/test/a/y", "/test/b/fooooo/bar"}
	for _, n := range names {
	if _, err := memstore.BindObject(fs.TP(n)).Put(nil, envelope); err != nil {
	t.Fatalf("Put() failed: %v", err)
	}
	}
	if err := memstore.BindTransaction(tname).Commit(nil); err != nil {
	t.Fatalf("Commit() failed: %v", err)
	}
	memstore.Unlock()
	// TRANSACTION END

	memstore.Lock()
	testcases := []struct {
	name string
	children []string
	}{
	{"/", []string{"test"}},
	{"/test", []string{"a", "b"}},
	{"/test/a", []string{"x", "y"}},
	{"/test/b", []string{"fooooo"}},
	{"/test/b/fooooo", []string{"bar"}},
	{"/test/a/x", nil},
	{"/test/a/y", nil},
	}
	for _, tc := range testcases {
	children, err := memstore.BindObject(tc.name).Children()
	if err != nil {
	t.Errorf("unexpected error for %q: %v", tc.name, err)
	continue
	}
	if !reflect.DeepEqual(children, tc.children) {
	t.Errorf("unexpected result for %q: got %q, expected %q", tc.name, children, tc.children)
	}
	}

	for _, notthere := range []string{"/doesnt-exist", "/tes"} {
	if _, err := memstore.BindObject(notthere).Children(); err == nil {
	t.Errorf("unexpected success for: %q", notthere)
	}
	}
	memstore.Unlock()
	}

	func TestFormatConversion(t *testing.T) {
	path := tempFile(t)
	defer os.Remove(path)
	originalMemstore, err := fs.NewMemstore(path)
	if err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}

	// Create example data.
	envelope := application.Envelope{
	Args: []string{"--help"},
	Env: []string{"DEBUG=1"},
	Binary: application.SignedFile{File: "/v23/name/of/binary"},
	}

	// TRANSACTION BEGIN
	// Insert a value into the legacy Memstore at /test/a
	originalMemstore.Lock()
	tname, err := originalMemstore.BindTransactionRoot("ignored").CreateTransaction(nil)
	if err != nil {
	t.Fatalf("CreateTransaction() failed: %v", err)
	}
	if _, err := originalMemstore.BindObject(fs.TP("/test/a")).Put(nil, envelope); err != nil {
	t.Fatalf("Put() failed: %v", err)
	}
	if err := originalMemstore.BindTransaction(tname).Commit(nil); err != nil {
	t.Fatalf("Commit() failed: %v", err)
	}
	originalMemstore.Unlock()

	// Write the original memstore to a GOB file.
	if err := gobPersist(t, originalMemstore); err != nil {
	t.Fatalf("gobPersist() failed: %v", err)
	}

	// Open the GOB format file.
	memstore, err := fs.NewMemstore(path)
	if err != nil {
	t.Fatalf("fs.NewMemstore() failed: %v", err)
	}

	// Verify the state.
	if err := allPathsEqual(memstore, []PathValue{{"/test/a", envelope}}); err != nil {
	t.Fatalf("%v", err)
	}
	}

	// gobPersist writes Memstore ms to its backing file.
	func gobPersist(t testing.T, ms fs.Memstore) error {
	// Convert this memstore to the legacy GOM format.
	data := ms.GetGOBConvertedMemstore()

	// Persist this file to a GOB format file.
	fname := ms.PersistedFile()
	file, err := os.Create(fname)
	if err != nil {
	t.Fatalf("os.Create(%s) failed: %v", fname, err)
	}
	defer file.Close()

	enc := gob.NewEncoder(file)
	err = enc.Encode(data)
	if err := enc.Encode(data); err != nil {
	t.Fatalf("enc.Encode() failed: %v", err)
	}
	return nil
	}