veyron/services/mountable/lib/mounttable: change all the testing to
not include any dependencies on the namespace package or '//'.

Change-Id: I186b9420af251444dccc1e9555822c3e861ca345
diff --git a/services/mounttable/lib/mounttable.go b/services/mounttable/lib/mounttable.go
index 4e90927..ce6e6f3 100644
--- a/services/mounttable/lib/mounttable.go
+++ b/services/mounttable/lib/mounttable.go
@@ -182,6 +182,8 @@
 }
 
 func slashSlashJoin(elems []string) string {
+	// TODO(p): once doubleslash is gone, revisit this.  It is just preserving the
+	// original double slash.
 	if len(elems) == 2 && len(elems[0]) == 0 && len(elems[1]) == 0 {
 		return "//"
 	}
diff --git a/services/mounttable/lib/mounttable_test.go b/services/mounttable/lib/mounttable_test.go
index 3cd964b..1780222 100644
--- a/services/mounttable/lib/mounttable_test.go
+++ b/services/mounttable/lib/mounttable_test.go
@@ -3,21 +3,19 @@
 import (
 	"errors"
 	"fmt"
+	"io"
 	"reflect"
 	"runtime/debug"
 	"sort"
-	"strings"
 	"testing"
 	"time"
 
 	"veyron.io/veyron/veyron2"
-	"veyron.io/veyron/veyron2/context"
 	"veyron.io/veyron/veyron2/ipc"
 	"veyron.io/veyron/veyron2/naming"
 	"veyron.io/veyron/veyron2/options"
 	"veyron.io/veyron/veyron2/rt"
 	"veyron.io/veyron/veyron2/security"
-	"veyron.io/veyron/veyron2/services/mounttable"
 	"veyron.io/veyron/veyron2/services/mounttable/types"
 	"veyron.io/veyron/veyron2/vlog"
 
@@ -25,12 +23,6 @@
 	"veyron.io/veyron/veyron/profiles"
 )
 
-// stupidNS is a version of naming.Namespace that we can control.  This exists so that we have some
-// firm ground to stand on vis a vis the stub interface.
-type stupidNS struct {
-	r veyron2.Runtime
-}
-
 // Simulate different processes with different runtimes.
 // rootRT is the one running the mounttable service.
 var rootRT, aliceRT, bobRT veyron2.Runtime
@@ -42,126 +34,119 @@
 	t.Fatal(string(debug.Stack()))
 }
 
-// quuxClient returns an ipc.Client that would be used by the provided runtime
-// and uses the simple namespace for name resolution.
-func quuxClient(r veyron2.Runtime) ipc.Client {
-	c, err := r.NewClient(options.Namespace{stupidNS{r}})
+func doMount(t *testing.T, ep, suffix, service string, shouldSucceed bool, as veyron2.Runtime) {
+	name := naming.JoinAddressName(ep, suffix)
+	ctx := as.NewContext()
+	client := as.Client()
+	call, err := client.StartCall(ctx, name, "Mount", []interface{}{service, uint32(ttlSecs), 0}, options.NoResolve(true))
 	if err != nil {
-		panic(err)
-	}
-	return c
-}
-
-func (stupidNS) Mount(context.T, string, string, time.Duration, ...naming.MountOpt) error {
-	return errors.New("unimplemented")
-}
-
-func (stupidNS) Unmount(context.T, string, string) error {
-	return errors.New("unimplemented")
-}
-
-// Resolve will only go one level deep, i.e., it doesn't walk past the first mount point.
-func (ns stupidNS) Resolve(ctx context.T, name string) ([]string, error) {
-	vlog.VI(1).Infof("MyResolve %q", name)
-	address, suffix := naming.SplitAddressName(name)
-	if len(address) == 0 {
-		return nil, naming.ErrNoSuchName
-	}
-	if strings.HasPrefix(suffix, "//") {
-		// We're done, the server at address will handle the name.
-		return []string{naming.JoinAddressName(address, suffix)}, nil
-	}
-
-	// Resolve via another
-	objectPtr, err := mounttable.BindMountTable("/"+address+"//"+suffix, quuxClient(ns.r))
-	if err != nil {
-		return nil, err
-	}
-	entry, err := objectPtr.ResolveStepX(ns.r.NewContext())
-	if err != nil {
-		return nil, err
-	}
-	var servers []string
-	for _, s := range entry.Servers {
-		servers = append(servers, naming.Join(s.Server, entry.Name))
-	}
-	vlog.VI(1).Infof("-> %v", servers)
-	return servers, nil
-}
-
-func (s stupidNS) Unresolve(ctx context.T, name string) ([]string, error) {
-	return s.Resolve(ctx, name)
-}
-
-func (stupidNS) ResolveToMountTable(ctx context.T, name string) ([]string, error) {
-	return nil, errors.New("ResolveToMountTable is not implemented in this MountTable")
-}
-
-func (stupidNS) FlushCacheEntry(name string) bool {
-	return false
-}
-
-func (stupidNS) CacheCtl(ctls ...naming.CacheCtl) []naming.CacheCtl {
-	return nil
-}
-
-// Glob implements naming.MountTable.Glob.
-func (stupidNS) Glob(ctx context.T, pattern string) (chan naming.MountEntry, error) {
-	return nil, errors.New("Glob is not implemented in this MountTable")
-}
-
-func (s stupidNS) SetRoots(...string) error {
-	return nil
-}
-
-func (s stupidNS) Roots() []string {
-	return []string{}
-}
-
-func doMount(t *testing.T, name, service string, shouldSucceed bool, as veyron2.Runtime) {
-	mtpt, err := mounttable.BindMountTable(name, quuxClient(as))
-	if err != nil {
-		boom(t, "Failed to BindMountTable: %s", err)
-	}
-	if err := mtpt.Mount(as.NewContext(), service, uint32(ttlSecs), 0, options.RetryTimeout(0)); err != nil {
-		if shouldSucceed {
-			boom(t, "Failed to Mount %s onto %s: %s", service, name, err)
+		if !shouldSucceed {
+			return
 		}
-	} else if !shouldSucceed {
-		boom(t, "doMount %s onto %s, expected failure but succeeded", service, name)
+		boom(t, "Failed to Mount %s onto %s: %s", service, name, err)
+	}
+	if ierr := call.Finish(&err); ierr != nil {
+		if !shouldSucceed {
+			return
+		}
+		boom(t, "Failed to Mount %s onto %s: %s", service, name, ierr)
+	}
+	if err != nil {
+		if !shouldSucceed {
+			return
+		}
+		boom(t, "Failed to Mount %s onto %s: %s", service, name, err)
 	}
 }
 
-func doUnmount(t *testing.T, name, service string, shouldSucceed bool, as veyron2.Runtime) {
-	mtpt, err := mounttable.BindMountTable(name, quuxClient(as))
+func doUnmount(t *testing.T, ep, suffix, service string, shouldSucceed bool, as veyron2.Runtime) {
+	name := naming.JoinAddressName(ep, suffix)
+	ctx := as.NewContext()
+	client := as.Client()
+	call, err := client.StartCall(ctx, name, "Unmount", []interface{}{service}, options.NoResolve(true))
 	if err != nil {
-		boom(t, "Failed to BindMountTable: %s", err)
-	}
-	if err := mtpt.Unmount(as.NewContext(), service, options.RetryTimeout(0)); err != nil {
-		if shouldSucceed {
-			boom(t, "Failed to Unmount %s onto %s: %s", service, name, err)
+		if !shouldSucceed {
+			return
 		}
-	} else if !shouldSucceed {
-		boom(t, "doUnmount %s onto %s, expected failure but succeeded", service, name)
+		boom(t, "Failed to Mount %s onto %s: %s", service, name, err)
 	}
+	if ierr := call.Finish(&err); ierr != nil {
+		if !shouldSucceed {
+			return
+		}
+		boom(t, "Failed to Mount %s onto %s: %s", service, name, ierr)
+	}
+	if err != nil {
+		if !shouldSucceed {
+			return
+		}
+		boom(t, "Failed to Mount %s onto %s: %s", service, name, err)
+	}
+}
+
+// resolve assumes that the mount contains 0 or 1 servers.
+func resolve(name string, as veyron2.Runtime) (string, error) {
+	// Resolve the name one level.
+	ctx := as.NewContext()
+	client := as.Client()
+	call, err := client.StartCall(ctx, name, "ResolveStepX", nil, options.NoResolve(true))
+	if err != nil {
+		return "", err
+	}
+	var entry types.MountEntry
+	if ierr := call.Finish(&entry, &err); ierr != nil {
+		return "", ierr
+	}
+	if len(entry.Servers) < 1 {
+		return "", errors.New("resolve returned no servers")
+	}
+	return naming.JoinAddressName(entry.Servers[0].Server, entry.Name), nil
 }
 
 func export(t *testing.T, name, contents string, as veyron2.Runtime) {
-	objectPtr, err := BindCollection(name, quuxClient(as))
+	// Resolve the name.
+	resolved, err := resolve(name, as)
 	if err != nil {
-		boom(t, "Failed to BindCollection: %s", err)
+		boom(t, "Failed to Export.Resolve %s: %s", name, err)
 	}
-	if err := objectPtr.Export(as.NewContext(), contents, true); err != nil {
-		boom(t, "Failed to Export %s to %s: %s", name, contents, err)
+	// Export the value.
+	ctx := as.NewContext()
+	client := as.Client()
+	call, err := client.StartCall(ctx, resolved, "Export", []interface{}{contents, true}, options.NoResolve(true))
+	if err != nil {
+		boom(t, "Failed to Export.StartCall %s to %s: %s", name, contents, err)
+	}
+	if ierr := call.Finish(&err); ierr != nil {
+		err = ierr
+	}
+	if err != nil {
+		boom(t, "Failed to Export.StartCall %s to %s: %s", name, contents, err)
 	}
 }
 
 func checkContents(t *testing.T, name, expected string, shouldSucceed bool, as veyron2.Runtime) {
-	objectPtr, err := BindCollection(name, quuxClient(as))
+	// Resolve the name.
+	resolved, err := resolve(name, as)
 	if err != nil {
-		boom(t, "Failed to BindCollection: %s", err)
+		if !shouldSucceed {
+			return
+		}
+		boom(t, "Failed to Resolve %s: %s", name, err)
 	}
-	contents, err := objectPtr.Lookup(as.NewContext(), options.RetryTimeout(0))
+	// Look up the value.
+	ctx := as.NewContext()
+	client := as.Client()
+	call, err := client.StartCall(ctx, resolved, "Lookup", nil, options.NoResolve(true))
+	if err != nil {
+		if shouldSucceed {
+			boom(t, "Failed Lookup.StartCall %s: %s", name, err)
+		}
+		return
+	}
+	var contents []byte
+	if ierr := call.Finish(&contents, &err); ierr != nil {
+		err = ierr
+	}
 	if err != nil {
 		if shouldSucceed {
 			boom(t, "Failed to Lookup %s: %s", name, err)
@@ -230,7 +215,7 @@
 
 	// Mount the collection server into the mount table.
 	vlog.Infof("Mount the collection server into the mount table.")
-	doMount(t, naming.JoinAddressName(mtAddr, "//mounttable/stuff"), collectionName, true, rootRT)
+	doMount(t, mtAddr, "mounttable/stuff", collectionName, true, rootRT)
 
 	// Create a few objects and make sure we can read them.
 	vlog.Infof("Create a few objects.")
@@ -248,9 +233,9 @@
 
 	// Test multiple mounts.
 	vlog.Infof("Multiple mounts.")
-	doMount(t, naming.JoinAddressName(mtAddr, "//mounttable//a/b"), collectionName, true, rootRT)
-	doMount(t, naming.JoinAddressName(mtAddr, "//mounttable/x/y"), collectionName, true, rootRT)
-	doMount(t, naming.JoinAddressName(mtAddr, "//mounttable/alpha//beta"), collectionName, true, rootRT)
+	doMount(t, mtAddr, "mounttable/a/b", collectionName, true, rootRT)
+	doMount(t, mtAddr, "mounttable/x/y", collectionName, true, rootRT)
+	doMount(t, mtAddr, "mounttable/alpha//beta", collectionName, true, rootRT)
 	vlog.Infof("Make sure we can read them.")
 	checkContents(t, naming.JoinAddressName(mtAddr, "mounttable/stuff/falls"), "falls mainly on the plain", true, rootRT)
 	checkContents(t, naming.JoinAddressName(mtAddr, "mounttable/a/b/falls"), "falls mainly on the plain", true, rootRT)
@@ -261,54 +246,69 @@
 
 	// Test generic unmount.
 	vlog.Info("Test generic unmount.")
-	doUnmount(t, naming.JoinAddressName(mtAddr, "//mounttable/a/b"), "", true, rootRT)
+	doUnmount(t, mtAddr, "mounttable/a/b", "", true, rootRT)
 	checkContents(t, naming.JoinAddressName(mtAddr, "mounttable/a/b/falls"), "falls mainly on the plain", false, rootRT)
 
 	// Test specific unmount.
 	vlog.Info("Test specific unmount.")
-	doMount(t, naming.JoinAddressName(mtAddr, "//mounttable/a/b"), collectionName, true, rootRT)
-	doUnmount(t, naming.JoinAddressName(mtAddr, "//mounttable/a/b"), collectionName, true, rootRT)
+	doMount(t, mtAddr, "mounttable/a/b", collectionName, true, rootRT)
+	doUnmount(t, mtAddr, "mounttable/a/b", collectionName, true, rootRT)
 	checkContents(t, naming.JoinAddressName(mtAddr, "mounttable/a/b/falls"), "falls mainly on the plain", false, rootRT)
 
 	// Try timing out a mount.
 	vlog.Info("Try timing out a mount.")
 	ft := NewFakeTimeClock()
 	setServerListClock(ft)
-	doMount(t, naming.JoinAddressName(mtAddr, "//mounttable/stuffWithTTL"), collectionName, true, rootRT)
+	doMount(t, mtAddr, "mounttable/stuffWithTTL", collectionName, true, rootRT)
 	checkContents(t, naming.JoinAddressName(mtAddr, "mounttable/stuffWithTTL/the/rain"), "the rain", true, rootRT)
 	ft.advance(time.Duration(ttlSecs+4) * time.Second)
 	checkContents(t, naming.JoinAddressName(mtAddr, "mounttable/stuffWithTTL/the/rain"), "the rain", false, rootRT)
 
 	// Test unauthorized mount.
 	vlog.Info("Test unauthorized mount.")
-	doMount(t, naming.JoinAddressName(mtAddr, "//mounttable//a/b"), collectionName, false, bobRT)
-	doMount(t, naming.JoinAddressName(mtAddr, "//mounttable//a/b"), collectionName, false, aliceRT)
+	doMount(t, mtAddr, "mounttable//a/b", collectionName, false, bobRT)
+	doMount(t, mtAddr, "mounttable//a/b", collectionName, false, aliceRT)
 
-	doUnmount(t, naming.JoinAddressName(mtAddr, "//mounttable/x/y"), collectionName, false, bobRT)
+	doUnmount(t, mtAddr, "mounttable/x/y", collectionName, false, bobRT)
 }
 
-func doGlob(t *testing.T, name, pattern string, as veyron2.Runtime) []string {
-	mtpt, err := mounttable.BindMountTable(name, quuxClient(as))
+func doGlobX(t *testing.T, ep, suffix, pattern string, as veyron2.Runtime, joinServer bool) []string {
+	name := naming.JoinAddressName(ep, suffix)
+	ctx := as.NewContext()
+	client := as.Client()
+	call, err := client.StartCall(ctx, name, "Glob", []interface{}{pattern}, options.NoResolve(true))
 	if err != nil {
-		boom(t, "Failed to BindMountTable: %s", err)
-	}
-	stream, err := mtpt.Glob(as.NewContext(), pattern)
-	if err != nil {
-		boom(t, "Failed call to %s.Glob(%s): %s", name, pattern, err)
+		boom(t, "Glob.StartCall %s %s: %s", name, pattern, err)
 	}
 	var reply []string
-	rStream := stream.RecvStream()
-	for rStream.Advance() {
-		e := rStream.Value()
-		reply = append(reply, e.Name)
+	for {
+		var e types.MountEntry
+		err := call.Recv(&e)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			boom(t, "Glob.StartCall %s: %s", name, pattern, err)
+		}
+		if joinServer && len(e.Servers) > 0 {
+			reply = append(reply, naming.JoinAddressName(e.Servers[0].Server, e.Name))
+		} else {
+			reply = append(reply, e.Name)
+		}
 	}
-
-	if err := rStream.Err(); err != nil {
-		boom(t, "Glob %s: %s", name, err)
+	if ierr := call.Finish(&err); ierr != nil {
+		err = ierr
+	}
+	if err != nil {
+		boom(t, "Glob.Finish %s: %s", name, pattern, err)
 	}
 	return reply
 }
 
+func doGlob(t *testing.T, ep, suffix, pattern string, as veyron2.Runtime) []string {
+	return doGlobX(t, ep, suffix, pattern, as, false)
+}
+
 // checkMatch verified that the two slices contain the same string items, albeit
 // not necessarily in the same order.  Item repetitions are allowed, but their
 // numbers need to match as well.
@@ -327,10 +327,10 @@
 	defer server.Stop()
 
 	// set up a mount space
-	fakeServer := naming.JoinAddressName(estr, "//quux")
-	doMount(t, naming.JoinAddressName(estr, "//one/bright/day"), fakeServer, true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//in/the/middle"), fakeServer, true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//of/the/night"), fakeServer, true, rootRT)
+	fakeServer := naming.JoinAddressName(estr, "quux")
+	doMount(t, estr, "one/bright/day", fakeServer, true, rootRT)
+	doMount(t, estr, "in/the/middle", fakeServer, true, rootRT)
+	doMount(t, estr, "of/the/night", fakeServer, true, rootRT)
 
 	// Try various globs.
 	tests := []struct {
@@ -348,39 +348,19 @@
 		{"", []string{""}},
 	}
 	for _, test := range tests {
-		out := doGlob(t, naming.JoinAddressName(estr, "//"), test.in, rootRT)
+		out := doGlob(t, estr, "", test.in, rootRT)
 		checkMatch(t, test.expected, out)
 	}
 
 	// Test Glob on a name that is under a mounted server. The result should the
 	// the address the mounted server with the extra suffix.
 	{
-		name := naming.JoinAddressName(estr, "//of/the/night/two/dead/boys/got/up/to/fight")
-		pattern := "*"
-		m, err := mounttable.BindGlobbable(name, quuxClient(rootRT))
-		if err != nil {
-			boom(t, "Failed to BindMountTable: %s", err)
-		}
-		stream, err := m.Glob(rootRT.NewContext(), pattern)
-		if err != nil {
-			boom(t, "Failed call to %s.Glob(%s): %s", name, pattern, err)
-		}
-		var results []types.MountEntry
-		iterator := stream.RecvStream()
-		for iterator.Advance() {
-			results = append(results, iterator.Value())
-		}
-		if err := iterator.Err(); err != nil {
-			boom(t, "Glob %s: %s", name, err)
-		}
+		results := doGlobX(t, estr, "of/the/night/two/dead/boys/got/up/to/fight", "*", rootRT, true)
 		if len(results) != 1 {
 			boom(t, "Unexpected number of results. Got %v, want 1", len(results))
 		}
-		if results[0].Name != "" {
-			boom(t, "Unexpected name. Got %v, want ''", results[0].Name)
-		}
-		_, suffix := naming.SplitAddressName(results[0].Servers[0].Server)
-		if expected := "//quux/two/dead/boys/got/up/to/fight"; suffix != expected {
+		_, suffix := naming.SplitAddressName(results[0])
+		if expected := "quux/two/dead/boys/got/up/to/fight"; suffix != expected {
 			boom(t, "Unexpected suffix. Got %v, want %v", suffix, expected)
 		}
 	}
@@ -394,8 +374,8 @@
 
 	// set up a mount space
 	fakeServer := naming.JoinAddressName(estr, "quux")
-	doMount(t, naming.JoinAddressName(estr, "//one/bright/day"), fakeServer, true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//a/b/c"), fakeServer, true, rootRT)
+	doMount(t, estr, "one/bright/day", fakeServer, true, rootRT)
+	doMount(t, estr, "a/b/c", fakeServer, true, rootRT)
 
 	// Try various globs.
 	tests := []struct {
@@ -411,7 +391,7 @@
 		{bobRT, "*/...", []string{"one", "one/bright", "one/bright/day"}},
 	}
 	for _, test := range tests {
-		out := doGlob(t, naming.JoinAddressName(estr, "//"), test.in, test.as)
+		out := doGlob(t, estr, "", test.in, test.as)
 		checkMatch(t, test.expected, out)
 	}
 }
@@ -420,12 +400,12 @@
 	server, estr := newMT(t, "")
 	defer server.Stop()
 
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/endpoint"), naming.JoinAddressName(estr, "life/on/the/mississippi"), true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/hostport"), "/atrampabroad:8000", true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/hostport-endpoint-platypus"), "/@atrampabroad:8000@@", true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/invalid/not/rooted"), "atrampabroad:8000", false, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/invalid/no/port"), "/atrampabroad", false, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/invalid/endpoint"), "/@following the equator:8000@@@", false, rootRT)
+	doMount(t, estr, "mounttable/endpoint", naming.JoinAddressName(estr, "life/on/the/mississippi"), true, rootRT)
+	doMount(t, estr, "mounttable/hostport", "/atrampabroad:8000", true, rootRT)
+	doMount(t, estr, "mounttable/hostport-endpoint-platypus", "/@atrampabroad:8000@@", true, rootRT)
+	doMount(t, estr, "mounttable/invalid/not/rooted", "atrampabroad:8000", false, rootRT)
+	doMount(t, estr, "mounttable/invalid/no/port", "/atrampabroad", false, rootRT)
+	doMount(t, estr, "mounttable/invalid/endpoint", "/@following the equator:8000@@@", false, rootRT)
 }
 
 func TestExpiry(t *testing.T) {
@@ -438,21 +418,21 @@
 
 	ft := NewFakeTimeClock()
 	setServerListClock(ft)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/a1/b1"), collectionName, true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/a1/b2"), collectionName, true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/a2/b1"), collectionName, true, rootRT)
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/a2/b2/c"), collectionName, true, rootRT)
+	doMount(t, estr, "mounttable/a1/b1", collectionName, true, rootRT)
+	doMount(t, estr, "mounttable/a1/b2", collectionName, true, rootRT)
+	doMount(t, estr, "mounttable/a2/b1", collectionName, true, rootRT)
+	doMount(t, estr, "mounttable/a2/b2/c", collectionName, true, rootRT)
 
-	checkMatch(t, []string{"a1/b1", "a2/b1"}, doGlob(t, naming.JoinAddressName(estr, "//mounttable"), "*/b1/...", rootRT))
+	checkMatch(t, []string{"a1/b1", "a2/b1"}, doGlob(t, estr, "mounttable", "*/b1/...", rootRT))
 	ft.advance(time.Duration(ttlSecs/2) * time.Second)
-	checkMatch(t, []string{"a1/b1", "a2/b1"}, doGlob(t, naming.JoinAddressName(estr, "//mounttable"), "*/b1/...", rootRT))
-	checkMatch(t, []string{"c"}, doGlob(t, naming.JoinAddressName(estr, "//mounttable/a2/b2"), "*", rootRT))
+	checkMatch(t, []string{"a1/b1", "a2/b1"}, doGlob(t, estr, "mounttable", "*/b1/...", rootRT))
+	checkMatch(t, []string{"c"}, doGlob(t, estr, "mounttable/a2/b2", "*", rootRT))
 	// Refresh only a1/b1.  All the other mounts will expire upon the next
 	// ft advance.
-	doMount(t, naming.JoinAddressName(estr, "//mounttable/a1/b1"), collectionName, true, rootRT)
+	doMount(t, estr, "mounttable/a1/b1", collectionName, true, rootRT)
 	ft.advance(time.Duration(ttlSecs/2+4) * time.Second)
-	checkMatch(t, []string{"a1"}, doGlob(t, naming.JoinAddressName(estr, "//mounttable"), "*", rootRT))
-	checkMatch(t, []string{"a1/b1"}, doGlob(t, naming.JoinAddressName(estr, "//mounttable"), "*/b1/...", rootRT))
+	checkMatch(t, []string{"a1"}, doGlob(t, estr, "mounttable", "*", rootRT))
+	checkMatch(t, []string{"a1/b1"}, doGlob(t, estr, "mounttable", "*/b1/...", rootRT))
 }
 
 func TestBadACLs(t *testing.T) {
diff --git a/services/mounttable/lib/neighborhood_test.go b/services/mounttable/lib/neighborhood_test.go
index 6dde49c..a935c44 100644
--- a/services/mounttable/lib/neighborhood_test.go
+++ b/services/mounttable/lib/neighborhood_test.go
@@ -8,7 +8,8 @@
 	"time"
 
 	"veyron.io/veyron/veyron2/naming"
-	"veyron.io/veyron/veyron2/services/mounttable"
+	"veyron.io/veyron/veyron2/options"
+	"veyron.io/veyron/veyron2/services/mounttable/types"
 	"veyron.io/veyron/veyron2/vlog"
 
 	"veyron.io/veyron/veyron/lib/testutil"
@@ -61,7 +62,7 @@
 	// Wait for the mounttable to appear in mdns
 L:
 	for tries := 1; tries < 2; tries++ {
-		names := doGlob(t, naming.JoinAddressName(estr, "//"), "*", rootRT)
+		names := doGlob(t, estr, "", "*", rootRT)
 		t.Logf("names %v", names)
 		for _, n := range names {
 			if n == serverName {
@@ -72,20 +73,23 @@
 	}
 
 	// Make sure we get back a root for the server.
-	want, got := []string{""}, doGlob(t, naming.JoinAddressName(estr, "//"+serverName), "", rootRT)
+	want, got := []string{""}, doGlob(t, estr, serverName, "", rootRT)
 	if !reflect.DeepEqual(want, got) {
 		t.Errorf("Unexpected Glob result want: %q, got: %q", want, got)
 	}
 
 	// Make sure we can resolve through the neighborhood.
 	expectedSuffix := "a/b"
-	objectPtr, err := mounttable.BindMountTable(naming.JoinAddressName(estr, "//"+serverName+"/"+expectedSuffix), quuxClient(rootRT))
-	if err != nil {
-		boom(t, "BindMountTable: %s", err)
+	ctx := rootRT.NewContext()
+	client := rootRT.Client()
+	name := naming.JoinAddressName(estr, serverName+"/"+expectedSuffix)
+	call, cerr := client.StartCall(ctx, name, "ResolveStepX", nil, options.NoResolve(true))
+	if cerr != nil {
+		boom(t, "ResolveStepX.StartCall: %s", cerr)
 	}
-	entry, err := objectPtr.ResolveStepX(rootRT.NewContext())
-	if err != nil {
-		boom(t, "resolveStep: %s", err)
+	var entry types.MountEntry
+	if cerr = call.Finish(&entry, &err); cerr != nil {
+		boom(t, "ResolveStepX: %s", cerr)
 	}
 
 	// Resolution returned something.  Make sure its correct.