diff --git a/builtin/logical/database/backend_test.go b/builtin/logical/database/backend_test.go
index eadce07726..de25a9693f 100644
--- a/builtin/logical/database/backend_test.go
+++ b/builtin/logical/database/backend_test.go
@@ -59,7 +59,7 @@ func preparePostgresTestContainer(t *testing.T, s logical.Storage, b logical.Bac
 	// exponential backoff-retry
 	if err = pool.Retry(func() error {
 		// This will cause a validation to run
-		resp, err := b.HandleRequest(namespace.TestContext(), &logical.Request{
+		resp, err := b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 			Storage:   s,
 			Operation: logical.UpdateOperation,
 			Path:      "config/postgresql",
@@ -228,7 +228,7 @@ func TestBackend_config_connection(t *testing.T) {
 			t.Fatal("expected not exists")
 		}
 
-		resp, err = b.HandleRequest(namespace.TestContext(), configReq)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), configReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%v resp:%#v\n", err, resp)
 		}
@@ -243,7 +243,7 @@ func TestBackend_config_connection(t *testing.T) {
 			"root_credentials_rotate_statements": []string{},
 		}
 		configReq.Operation = logical.ReadOperation
-		resp, err = b.HandleRequest(namespace.TestContext(), configReq)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), configReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, resp)
 		}
@@ -280,7 +280,7 @@ func TestBackend_config_connection(t *testing.T) {
 			t.Fatal("expected exists")
 		}
 
-		resp, err = b.HandleRequest(namespace.TestContext(), configReq)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), configReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%v resp:%#v\n", err, resp)
 		}
@@ -295,7 +295,7 @@ func TestBackend_config_connection(t *testing.T) {
 			"root_credentials_rotate_statements": []string{},
 		}
 		configReq.Operation = logical.ReadOperation
-		resp, err = b.HandleRequest(namespace.TestContext(), configReq)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), configReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, resp)
 		}
@@ -321,7 +321,7 @@ func TestBackend_config_connection(t *testing.T) {
 			Data:      configData,
 		}
 
-		resp, err = b.HandleRequest(namespace.TestContext(), configReq)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), configReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%v resp:%#v\n", err, resp)
 		}
@@ -336,7 +336,7 @@ func TestBackend_config_connection(t *testing.T) {
 			"root_credentials_rotate_statements": []string{},
 		}
 		configReq.Operation = logical.ReadOperation
-		resp, err = b.HandleRequest(namespace.TestContext(), configReq)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), configReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, resp)
 		}
@@ -352,7 +352,7 @@ func TestBackend_config_connection(t *testing.T) {
 		Storage:   config.StorageView,
 		Path:      "config/",
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -382,7 +382,7 @@ func TestBackend_BadConnectionString(t *testing.T) {
 
 	respCheck := func(req *logical.Request) {
 		t.Helper()
-		resp, err := b.HandleRequest(namespace.TestContext(), req)
+		resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -441,7 +441,7 @@ func TestBackend_basic(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -458,7 +458,7 @@ func TestBackend_basic(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -470,7 +470,7 @@ func TestBackend_basic(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err := b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
@@ -487,7 +487,7 @@ func TestBackend_basic(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -499,7 +499,7 @@ func TestBackend_basic(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err = b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
@@ -520,7 +520,7 @@ func TestBackend_basic(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -534,7 +534,7 @@ func TestBackend_basic(t *testing.T) {
 			Storage:   config.StorageView,
 			Data:      data,
 		}
-		credsResp, err = b.HandleRequest(namespace.TestContext(), req)
+		credsResp, err = b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (credsResp != nil && credsResp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 		}
@@ -547,7 +547,7 @@ func TestBackend_basic(t *testing.T) {
 		}
 
 		// Revoke creds
-		resp, err = b.HandleRequest(namespace.TestContext(), &logical.Request{
+		resp, err = b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 			Operation: logical.RevokeOperation,
 			Storage:   config.StorageView,
 			Secret: &logical.Secret{
@@ -576,7 +576,7 @@ func TestBackend_basic(t *testing.T) {
 			Storage:   config.StorageView,
 			Data:      data,
 		}
-		credsResp, err = b.HandleRequest(namespace.TestContext(), req)
+		credsResp, err = b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (credsResp != nil && credsResp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 		}
@@ -590,13 +590,13 @@ func TestBackend_basic(t *testing.T) {
 			Path:      "roles/plugin-role-test",
 			Storage:   config.StorageView,
 		}
-		resp, err = b.HandleRequest(namespace.TestContext(), req)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, resp)
 		}
 
 		// Revoke creds
-		resp, err = b.HandleRequest(namespace.TestContext(), &logical.Request{
+		resp, err = b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 			Operation: logical.RevokeOperation,
 			Storage:   config.StorageView,
 			Secret: &logical.Secret{
@@ -648,7 +648,7 @@ func TestBackend_connectionCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -667,7 +667,7 @@ func TestBackend_connectionCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -686,7 +686,7 @@ func TestBackend_connectionCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -695,7 +695,7 @@ func TestBackend_connectionCrud(t *testing.T) {
 	}
 
 	req.Operation = logical.ReadOperation
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -707,7 +707,7 @@ func TestBackend_connectionCrud(t *testing.T) {
 	req.Operation = logical.UpdateOperation
 	connURL = strings.Replace(connURL, "postgres:secret", "{{username}}:{{password}}", -1)
 	data["connection_url"] = connURL
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -723,7 +723,7 @@ func TestBackend_connectionCrud(t *testing.T) {
 		"root_credentials_rotate_statements": []string(nil),
 	}
 	req.Operation = logical.ReadOperation
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -741,7 +741,7 @@ func TestBackend_connectionCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -754,7 +754,7 @@ func TestBackend_connectionCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err := b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
@@ -775,14 +775,14 @@ func TestBackend_connectionCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
 
 	// Read connection
 	req.Operation = logical.ReadOperation
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -825,7 +825,7 @@ func TestBackend_roleCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -845,7 +845,7 @@ func TestBackend_roleCrud(t *testing.T) {
 			Storage:   config.StorageView,
 			Data:      data,
 		}
-		resp, err = b.HandleRequest(namespace.TestContext(), req)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, resp)
 		}
@@ -869,7 +869,7 @@ func TestBackend_roleCrud(t *testing.T) {
 			Storage:   config.StorageView,
 			Data:      data,
 		}
-		resp, err = b.HandleRequest(namespace.TestContext(), req)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, resp)
 		}
@@ -913,7 +913,7 @@ func TestBackend_roleCrud(t *testing.T) {
 			Storage:   config.StorageView,
 			Data:      data,
 		}
-		resp, err = b.HandleRequest(namespace.TestContext(), req)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%v resp:%#v\n", err, resp)
 		}
@@ -937,7 +937,7 @@ func TestBackend_roleCrud(t *testing.T) {
 			Storage:   config.StorageView,
 			Data:      data,
 		}
-		resp, err = b.HandleRequest(namespace.TestContext(), req)
+		resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%s resp:%#v\n", err, resp)
 		}
@@ -1051,7 +1051,7 @@ func TestBackend_roleCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1064,7 +1064,7 @@ func TestBackend_roleCrud(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1102,7 +1102,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1120,7 +1120,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1137,7 +1137,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1150,7 +1150,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err := b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrPermissionDenied {
 		t.Fatalf("expected error to be:%s got:%#v\n", logical.ErrPermissionDenied, err)
 	}
@@ -1167,7 +1167,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1180,7 +1180,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err = b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
@@ -1201,7 +1201,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1214,7 +1214,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err = b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
@@ -1235,7 +1235,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1248,7 +1248,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err = b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrPermissionDenied {
 		t.Fatalf("expected error to be:%s got:%#v\n", logical.ErrPermissionDenied, err)
 	}
@@ -1261,7 +1261,7 @@ func TestBackend_allowedRoles(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err = b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
@@ -1304,7 +1304,7 @@ func TestBackend_RotateRootCredentials(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1321,7 +1321,7 @@ func TestBackend_RotateRootCredentials(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, resp)
 	}
@@ -1333,7 +1333,7 @@ func TestBackend_RotateRootCredentials(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err := b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
@@ -1345,7 +1345,7 @@ func TestBackend_RotateRootCredentials(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
@@ -1366,7 +1366,7 @@ func TestBackend_RotateRootCredentials(t *testing.T) {
 		Storage:   config.StorageView,
 		Data:      data,
 	}
-	credsResp, err = b.HandleRequest(namespace.TestContext(), req)
+	credsResp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (credsResp != nil && credsResp.IsError()) {
 		t.Fatalf("err:%s resp:%#v\n", err, credsResp)
 	}
diff --git a/builtin/logical/database/dbplugin/plugin_test.go b/builtin/logical/database/dbplugin/plugin_test.go
index baaacb78d3..8b5ebee5bc 100644
--- a/builtin/logical/database/dbplugin/plugin_test.go
+++ b/builtin/logical/database/dbplugin/plugin_test.go
@@ -149,7 +149,7 @@ func TestPlugin_Init(t *testing.T) {
 	cluster, sys := getCluster(t)
 	defer cluster.Cleanup()
 
-	dbRaw, err := dbplugin.PluginFactory(namespace.TestContext(), "test-plugin", sys, log.NewNullLogger())
+	dbRaw, err := dbplugin.PluginFactory(namespace.RootContext(nil), "test-plugin", sys, log.NewNullLogger())
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -173,7 +173,7 @@ func TestPlugin_CreateUser(t *testing.T) {
 	cluster, sys := getCluster(t)
 	defer cluster.Cleanup()
 
-	db, err := dbplugin.PluginFactory(namespace.TestContext(), "test-plugin", sys, log.NewNullLogger())
+	db, err := dbplugin.PluginFactory(namespace.RootContext(nil), "test-plugin", sys, log.NewNullLogger())
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -213,7 +213,7 @@ func TestPlugin_RenewUser(t *testing.T) {
 	cluster, sys := getCluster(t)
 	defer cluster.Cleanup()
 
-	db, err := dbplugin.PluginFactory(namespace.TestContext(), "test-plugin", sys, log.NewNullLogger())
+	db, err := dbplugin.PluginFactory(namespace.RootContext(nil), "test-plugin", sys, log.NewNullLogger())
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -247,7 +247,7 @@ func TestPlugin_RevokeUser(t *testing.T) {
 	cluster, sys := getCluster(t)
 	defer cluster.Cleanup()
 
-	db, err := dbplugin.PluginFactory(namespace.TestContext(), "test-plugin", sys, log.NewNullLogger())
+	db, err := dbplugin.PluginFactory(namespace.RootContext(nil), "test-plugin", sys, log.NewNullLogger())
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -289,7 +289,7 @@ func TestPlugin_NetRPC_Init(t *testing.T) {
 	cluster, sys := getCluster(t)
 	defer cluster.Cleanup()
 
-	dbRaw, err := dbplugin.PluginFactory(namespace.TestContext(), "test-plugin-netRPC", sys, log.NewNullLogger())
+	dbRaw, err := dbplugin.PluginFactory(namespace.RootContext(nil), "test-plugin-netRPC", sys, log.NewNullLogger())
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -313,7 +313,7 @@ func TestPlugin_NetRPC_CreateUser(t *testing.T) {
 	cluster, sys := getCluster(t)
 	defer cluster.Cleanup()
 
-	db, err := dbplugin.PluginFactory(namespace.TestContext(), "test-plugin-netRPC", sys, log.NewNullLogger())
+	db, err := dbplugin.PluginFactory(namespace.RootContext(nil), "test-plugin-netRPC", sys, log.NewNullLogger())
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -353,7 +353,7 @@ func TestPlugin_NetRPC_RenewUser(t *testing.T) {
 	cluster, sys := getCluster(t)
 	defer cluster.Cleanup()
 
-	db, err := dbplugin.PluginFactory(namespace.TestContext(), "test-plugin-netRPC", sys, log.NewNullLogger())
+	db, err := dbplugin.PluginFactory(namespace.RootContext(nil), "test-plugin-netRPC", sys, log.NewNullLogger())
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -387,7 +387,7 @@ func TestPlugin_NetRPC_RevokeUser(t *testing.T) {
 	cluster, sys := getCluster(t)
 	defer cluster.Cleanup()
 
-	db, err := dbplugin.PluginFactory(namespace.TestContext(), "test-plugin-netRPC", sys, log.NewNullLogger())
+	db, err := dbplugin.PluginFactory(namespace.RootContext(nil), "test-plugin-netRPC", sys, log.NewNullLogger())
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
diff --git a/helper/namespace/namespace.go b/helper/namespace/namespace.go
index 1d21491ac9..e47a27f3bb 100644
--- a/helper/namespace/namespace.go
+++ b/helper/namespace/namespace.go
@@ -75,14 +75,6 @@ func FromContext(ctx context.Context) (*Namespace, error) {
 	return ns, nil
 }
 
-func TestContext() context.Context {
-	return ContextWithNamespace(context.Background(), TestNamespace())
-}
-
-func TestNamespace() *Namespace {
-	return RootNamespace
-}
-
 // Canonicalize trims any prefix '/' and adds a trailing '/' to the
 // provided string
 func Canonicalize(nsPath string) string {
diff --git a/logical/testing/testing.go b/logical/testing/testing.go
index 1b65d0baec..e3ada93b02 100644
--- a/logical/testing/testing.go
+++ b/logical/testing/testing.go
@@ -270,7 +270,7 @@ func Test(tt TestT, c TestCase) {
 		req.Path = fmt.Sprintf("%s/%s", prefix, req.Path)
 
 		// Make the request
-		resp, err := core.HandleRequest(namespace.TestContext(), req)
+		resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 		if resp != nil && resp.Secret != nil {
 			// Revoke this secret later
 			revoke = append(revoke, &logical.Request{
@@ -324,7 +324,7 @@ func Test(tt TestT, c TestCase) {
 			logger.Warn("Revoking secret", "secret", fmt.Sprintf("%#v", req))
 		}
 		req.ClientToken = client.Token()
-		resp, err := core.HandleRequest(namespace.TestContext(), req)
+		resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 		if err == nil && resp.IsError() {
 			err = fmt.Errorf("erroneous response:\n\n%#v", resp)
 		}
@@ -341,7 +341,7 @@ func Test(tt TestT, c TestCase) {
 	req := logical.RollbackRequest(prefix + "/")
 	req.Data["immediate"] = true
 	req.ClientToken = client.Token()
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil && resp.IsError() {
 		err = fmt.Errorf("erroneous response:\n\n%#v", resp)
 	}
diff --git a/vault/acl_test.go b/vault/acl_test.go
index f76c918f3e..fd84b94ec6 100644
--- a/vault/acl_test.go
+++ b/vault/acl_test.go
@@ -159,7 +159,7 @@ func testACLRoot(t *testing.T, ns *namespace.Namespace) {
 	// Create the root policy ACL. Always create on root namespace regardless of
 	// which namespace to ACL check on.
 	policy := []*Policy{&Policy{Name: "root"}}
-	acl, err := NewACL(namespace.TestContext(), policy)
+	acl, err := NewACL(namespace.RootContext(nil), policy)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -598,7 +598,7 @@ func TestACL_CreationRace(t *testing.T) {
 				if time.Now().After(stopTime) {
 					return
 				}
-				_, err := NewACL(namespace.TestContext(), []*Policy{policy})
+				_, err := NewACL(namespace.RootContext(nil), []*Policy{policy})
 				if err != nil {
 					t.Fatalf("err: %v", err)
 				}
diff --git a/vault/audit_test.go b/vault/audit_test.go
index 956d5036ce..1e262a0f87 100644
--- a/vault/audit_test.go
+++ b/vault/audit_test.go
@@ -123,7 +123,7 @@ func TestAudit_ReadOnlyViewDuringMount(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err := c.enableAudit(namespace.TestContext(), me, true)
+	err := c.enableAudit(namespace.RootContext(nil), me, true)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -142,7 +142,7 @@ func TestCore_EnableAudit(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err := c.enableAudit(namespace.TestContext(), me, true)
+	err := c.enableAudit(namespace.RootContext(nil), me, true)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -262,7 +262,7 @@ func TestCore_EnableAudit_Local(t *testing.T) {
 				UUID:        "abcd",
 				Accessor:    "noop-abcd",
 				NamespaceID: namespace.RootNamespaceID,
-				namespace:   namespace.TestNamespace(),
+				namespace:   namespace.RootNamespace,
 			},
 			&MountEntry{
 				Table:       auditTableType,
@@ -271,7 +271,7 @@ func TestCore_EnableAudit_Local(t *testing.T) {
 				UUID:        "bcde",
 				Accessor:    "noop-bcde",
 				NamespaceID: namespace.RootNamespaceID,
-				namespace:   namespace.TestNamespace(),
+				namespace:   namespace.RootNamespace,
 			},
 		},
 	}
@@ -339,7 +339,7 @@ func TestCore_DisableAudit(t *testing.T) {
 		}, nil
 	}
 
-	existed, err := c.disableAudit(namespace.TestContext(), "foo", true)
+	existed, err := c.disableAudit(namespace.RootContext(nil), "foo", true)
 	if existed && err != nil {
 		t.Fatalf("existed: %v; err: %v", existed, err)
 	}
@@ -349,12 +349,12 @@ func TestCore_DisableAudit(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err = c.enableAudit(namespace.TestContext(), me, true)
+	err = c.enableAudit(namespace.RootContext(nil), me, true)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	existed, err = c.disableAudit(namespace.TestContext(), "foo", true)
+	existed, err = c.disableAudit(namespace.RootContext(nil), "foo", true)
 	if !existed || err != nil {
 		t.Fatalf("existed: %v; err: %v", existed, err)
 	}
diff --git a/vault/auth_test.go b/vault/auth_test.go
index a17373d268..22fbacd36c 100644
--- a/vault/auth_test.go
+++ b/vault/auth_test.go
@@ -29,7 +29,7 @@ func TestAuth_ReadOnlyViewDuringMount(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err := c.enableCredential(namespace.TestContext(), me)
+	err := c.enableCredential(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -75,12 +75,12 @@ func TestCore_EnableCredential(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err := c.enableCredential(namespace.TestContext(), me)
+	err := c.enableCredential(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	match := c.router.MatchingMount(namespace.TestContext(), "auth/foo/bar")
+	match := c.router.MatchingMount(namespace.RootContext(nil), "auth/foo/bar")
 	if match != "auth/foo/" {
 		t.Fatalf("missing mount, match: %q", match)
 	}
@@ -132,7 +132,7 @@ func TestCore_EnableCredential_Local(t *testing.T) {
 				Accessor:         "noop-abcd",
 				BackendAwareUUID: "abcde",
 				NamespaceID:      namespace.RootNamespaceID,
-				namespace:        namespace.TestNamespace(),
+				namespace:        namespace.RootNamespace,
 			},
 			&MountEntry{
 				Table:            credentialTableType,
@@ -142,7 +142,7 @@ func TestCore_EnableCredential_Local(t *testing.T) {
 				Accessor:         "noop-bcde",
 				BackendAwareUUID: "bcdea",
 				NamespaceID:      namespace.RootNamespaceID,
-				namespace:        namespace.TestNamespace(),
+				namespace:        namespace.RootNamespace,
 			},
 		},
 	}
@@ -213,13 +213,13 @@ func TestCore_EnableCredential_twice_409(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err := c.enableCredential(namespace.TestContext(), me)
+	err := c.enableCredential(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// 2nd should be a 409 error
-	err2 := c.enableCredential(namespace.TestContext(), me)
+	err2 := c.enableCredential(namespace.RootContext(nil), me)
 	switch err2.(type) {
 	case logical.HTTPCodedError:
 		if err2.(logical.HTTPCodedError).Code() != 409 {
@@ -237,7 +237,7 @@ func TestCore_EnableCredential_Token(t *testing.T) {
 		Path:  "foo",
 		Type:  "token",
 	}
-	err := c.enableCredential(namespace.TestContext(), me)
+	err := c.enableCredential(namespace.RootContext(nil), me)
 	if err.Error() != "token credential backend cannot be instantiated" {
 		t.Fatalf("err: %v", err)
 	}
@@ -249,7 +249,7 @@ func TestCore_DisableCredential(t *testing.T) {
 		return &NoopBackend{}, nil
 	}
 
-	err := c.disableCredential(namespace.TestContext(), "foo")
+	err := c.disableCredential(namespace.RootContext(nil), "foo")
 	if err != nil && !strings.HasPrefix(err.Error(), "no matching mount") {
 		t.Fatal(err)
 	}
@@ -259,17 +259,17 @@ func TestCore_DisableCredential(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err = c.enableCredential(namespace.TestContext(), me)
+	err = c.enableCredential(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	err = c.disableCredential(namespace.TestContext(), "foo")
+	err = c.disableCredential(namespace.RootContext(nil), "foo")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	match := c.router.MatchingMount(namespace.TestContext(), "auth/foo/bar")
+	match := c.router.MatchingMount(namespace.RootContext(nil), "auth/foo/bar")
 	if match != "" {
 		t.Fatalf("backend present")
 	}
@@ -300,7 +300,7 @@ func TestCore_DisableCredential(t *testing.T) {
 
 func TestCore_DisableCredential_Protected(t *testing.T) {
 	c, _, _ := TestCoreUnsealed(t)
-	err := c.disableCredential(namespace.TestContext(), "token")
+	err := c.disableCredential(namespace.RootContext(nil), "token")
 	if err.Error() != "token credential backend cannot be disabled" {
 		t.Fatalf("err: %v", err)
 	}
@@ -320,13 +320,13 @@ func TestCore_DisableCredential_Cleanup(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err := c.enableCredential(namespace.TestContext(), me)
+	err := c.enableCredential(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Store the view
-	view := c.router.MatchingStorageByAPIPath(namespace.TestContext(), "auth/foo/")
+	view := c.router.MatchingStorageByAPIPath(namespace.RootContext(nil), "auth/foo/")
 
 	// Inject data
 	se := &logical.StorageEntry{
@@ -347,7 +347,7 @@ func TestCore_DisableCredential_Cleanup(t *testing.T) {
 		Operation: logical.ReadOperation,
 		Path:      "auth/foo/login",
 	}
-	resp, err := c.HandleRequest(namespace.TestContext(), r)
+	resp, err := c.HandleRequest(namespace.RootContext(nil), r)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -356,13 +356,13 @@ func TestCore_DisableCredential_Cleanup(t *testing.T) {
 	}
 
 	// Disable should cleanup
-	err = c.disableCredential(namespace.TestContext(), "foo")
+	err = c.disableCredential(namespace.RootContext(nil), "foo")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Token should be revoked
-	te, err := c.tokenStore.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	te, err := c.tokenStore.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
diff --git a/vault/expiration_test.go b/vault/expiration_test.go
index a089acf844..fc55c8c00a 100644
--- a/vault/expiration_test.go
+++ b/vault/expiration_test.go
@@ -65,7 +65,7 @@ func TestExpiration_Tidy(t *testing.T) {
 	}
 
 	// Scan the storage with the count func set
-	if err = logical.ScanView(namespace.TestContext(), exp.idView, countFunc); err != nil {
+	if err = logical.ScanView(namespace.RootContext(nil), exp.idView, countFunc); err != nil {
 		t.Fatal(err)
 	}
 
@@ -78,11 +78,11 @@ func TestExpiration_Tidy(t *testing.T) {
 	le := &leaseEntry{
 		LeaseID:   "lease/with/no/client/token",
 		Path:      "foo/bar",
-		namespace: namespace.TestNamespace(),
+		namespace: namespace.RootNamespace,
 	}
 
 	// Persist the invalid lease entry
-	if err = exp.persistEntry(namespace.TestContext(), le); err != nil {
+	if err = exp.persistEntry(namespace.RootContext(nil), le); err != nil {
 		t.Fatalf("error persisting entry: %v", err)
 	}
 
@@ -98,7 +98,7 @@ func TestExpiration_Tidy(t *testing.T) {
 	}
 
 	// Run the tidy operation
-	err = exp.Tidy(namespace.TestContext())
+	err = exp.Tidy(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -117,7 +117,7 @@ func TestExpiration_Tidy(t *testing.T) {
 	le.ClientToken = "invalidtoken"
 
 	// Persist the invalid lease entry
-	if err = exp.persistEntry(namespace.TestContext(), le); err != nil {
+	if err = exp.persistEntry(namespace.RootContext(nil), le); err != nil {
 		t.Fatalf("error persisting entry: %v", err)
 	}
 
@@ -133,7 +133,7 @@ func TestExpiration_Tidy(t *testing.T) {
 	}
 
 	// Run the tidy operation
-	err = exp.Tidy(namespace.TestContext())
+	err = exp.Tidy(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -149,7 +149,7 @@ func TestExpiration_Tidy(t *testing.T) {
 	}
 
 	// Attach an invalid token with 2 leases
-	if err = exp.persistEntry(namespace.TestContext(), le); err != nil {
+	if err = exp.persistEntry(namespace.RootContext(nil), le); err != nil {
 		t.Fatalf("error persisting entry: %v", err)
 	}
 
@@ -159,7 +159,7 @@ func TestExpiration_Tidy(t *testing.T) {
 	}
 
 	// Run the tidy operation
-	err = exp.Tidy(namespace.TestContext())
+	err = exp.Tidy(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -191,7 +191,7 @@ func TestExpiration_Tidy(t *testing.T) {
 				"test_key": "test_value",
 			},
 		}
-		_, err := exp.Register(namespace.TestContext(), req, resp)
+		_, err := exp.Register(namespace.RootContext(nil), req, resp)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -214,11 +214,11 @@ func TestExpiration_Tidy(t *testing.T) {
 	// one tidy operation can be in flight at any time. One of these requests
 	// should error out.
 	go func() {
-		errCh1 <- exp.Tidy(namespace.TestContext())
+		errCh1 <- exp.Tidy(namespace.RootContext(nil))
 	}()
 
 	go func() {
-		errCh2 <- exp.Tidy(namespace.TestContext())
+		errCh2 <- exp.Tidy(namespace.RootContext(nil))
 	}()
 
 	var err1, err2 error
@@ -244,12 +244,12 @@ func TestExpiration_Tidy(t *testing.T) {
 	le.ClientToken = root.ID
 
 	// Attach a valid token with the leases
-	if err = exp.persistEntry(namespace.TestContext(), le); err != nil {
+	if err = exp.persistEntry(namespace.RootContext(nil), le); err != nil {
 		t.Fatalf("error persisting entry: %v", err)
 	}
 
 	// Run the tidy operation
-	err = exp.Tidy(namespace.TestContext())
+	err = exp.Tidy(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -321,7 +321,7 @@ func benchmarkExpirationBackend(b *testing.B, physicalBackend physical.Backend,
 	if err != nil {
 		b.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -381,7 +381,7 @@ func TestExpiration_Restore(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -409,7 +409,7 @@ func TestExpiration_Restore(t *testing.T) {
 				"secret_key": "abcd",
 			},
 		}
-		_, err := exp.Register(namespace.TestContext(), req, resp)
+		_, err := exp.Register(namespace.RootContext(nil), req, resp)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -467,7 +467,7 @@ func TestExpiration_Register(t *testing.T) {
 		},
 	}
 
-	id, err := exp.Register(namespace.TestContext(), req, resp)
+	id, err := exp.Register(namespace.RootContext(nil), req, resp)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -499,7 +499,7 @@ func TestExpiration_RegisterAuth(t *testing.T) {
 		Path:        "auth/github/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -508,7 +508,7 @@ func TestExpiration_RegisterAuth(t *testing.T) {
 		Path:        "auth/github/../login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err == nil {
 		t.Fatal("expected error")
 	}
@@ -530,7 +530,7 @@ func TestExpiration_RegisterAuth_NoLease(t *testing.T) {
 		Path:        "auth/github/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -541,7 +541,7 @@ func TestExpiration_RegisterAuth_NoLease(t *testing.T) {
 		Path:        "auth/github/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	resp, err := exp.RenewToken(namespace.TestContext(), &logical.Request{}, te, 0)
+	resp, err := exp.RenewToken(namespace.RootContext(nil), &logical.Request{}, te, 0)
 	if err != nil && (err != logical.ErrInvalidRequest || (resp != nil && resp.IsError() && resp.Error().Error() != "lease is not renewable")) {
 		t.Fatalf("bad: err:%v resp:%#v", err, resp)
 	}
@@ -553,7 +553,7 @@ func TestExpiration_RegisterAuth_NoLease(t *testing.T) {
 	time.Sleep(20 * time.Millisecond)
 
 	// Verify token does not get revoked
-	out, err := exp.tokenStore.Lookup(namespace.TestContext(), root.ID)
+	out, err := exp.tokenStore.Lookup(namespace.RootContext(nil), root.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -571,7 +571,7 @@ func TestExpiration_Revoke(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -594,12 +594,12 @@ func TestExpiration_Revoke(t *testing.T) {
 		},
 	}
 
-	id, err := exp.Register(namespace.TestContext(), req, resp)
+	id, err := exp.Register(namespace.RootContext(nil), req, resp)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	if err := exp.Revoke(namespace.TestContext(), id); err != nil {
+	if err := exp.Revoke(namespace.RootContext(nil), id); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -618,7 +618,7 @@ func TestExpiration_RevokeOnExpire(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -641,7 +641,7 @@ func TestExpiration_RevokeOnExpire(t *testing.T) {
 		},
 	}
 
-	_, err = exp.Register(namespace.TestContext(), req, resp)
+	_, err = exp.Register(namespace.RootContext(nil), req, resp)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -676,7 +676,7 @@ func TestExpiration_RevokePrefix(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -704,14 +704,14 @@ func TestExpiration_RevokePrefix(t *testing.T) {
 				"secret_key": "abcd",
 			},
 		}
-		_, err := exp.Register(namespace.TestContext(), req, resp)
+		_, err := exp.Register(namespace.RootContext(nil), req, resp)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
 	}
 
 	// Should nuke all the keys
-	if err := exp.RevokePrefix(namespace.TestContext(), "prod/aws/", true); err != nil {
+	if err := exp.RevokePrefix(namespace.RootContext(nil), "prod/aws/", true); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -745,7 +745,7 @@ func TestExpiration_RevokeByToken(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -773,7 +773,7 @@ func TestExpiration_RevokeByToken(t *testing.T) {
 				"secret_key": "abcd",
 			},
 		}
-		_, err := exp.Register(namespace.TestContext(), req, resp)
+		_, err := exp.Register(namespace.RootContext(nil), req, resp)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -784,7 +784,7 @@ func TestExpiration_RevokeByToken(t *testing.T) {
 		ID:          "foobarbaz",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	if err := exp.RevokeByToken(namespace.TestContext(), te); err != nil {
+	if err := exp.RevokeByToken(namespace.RootContext(nil), te); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -834,7 +834,7 @@ func TestExpiration_RevokeByToken_Blocking(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -862,7 +862,7 @@ func TestExpiration_RevokeByToken_Blocking(t *testing.T) {
 				"secret_key": "abcd",
 			},
 		}
-		_, err := exp.Register(namespace.TestContext(), req, resp)
+		_, err := exp.Register(namespace.RootContext(nil), req, resp)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -873,7 +873,7 @@ func TestExpiration_RevokeByToken_Blocking(t *testing.T) {
 		ID:          "foobarbaz",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	if err := exp.RevokeByToken(namespace.TestContext(), te); err != nil {
+	if err := exp.RevokeByToken(namespace.RootContext(nil), te); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -934,7 +934,7 @@ func TestExpiration_RenewToken(t *testing.T) {
 		Path:        "auth/token/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -945,7 +945,7 @@ func TestExpiration_RenewToken(t *testing.T) {
 		Path:        "auth/token/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	out, err := exp.RenewToken(namespace.TestContext(), &logical.Request{}, te, 0)
+	out, err := exp.RenewToken(namespace.RootContext(nil), &logical.Request{}, te, 0)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -965,7 +965,7 @@ func TestExpiration_RenewToken_period(t *testing.T) {
 		Period:       time.Minute,
 		NamespaceID:  namespace.RootNamespaceID,
 	}
-	if err := exp.tokenStore.create(namespace.TestContext(), root); err != nil {
+	if err := exp.tokenStore.create(namespace.RootContext(nil), root); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -983,7 +983,7 @@ func TestExpiration_RenewToken_period(t *testing.T) {
 		Path:        "auth/token/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	err := exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err := exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -994,7 +994,7 @@ func TestExpiration_RenewToken_period(t *testing.T) {
 		Path:        "auth/token/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	out, err := exp.RenewToken(namespace.TestContext(), &logical.Request{}, te, 0)
+	out, err := exp.RenewToken(namespace.RootContext(nil), &logical.Request{}, te, 0)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1036,7 +1036,7 @@ func TestExpiration_RenewToken_period_backend(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "auth/foo/", &MountEntry{Path: "auth/foo/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "auth/foo/", &MountEntry{Path: "auth/foo/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1056,7 +1056,7 @@ func TestExpiration_RenewToken_period_backend(t *testing.T) {
 		NamespaceID: namespace.RootNamespaceID,
 	}
 
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1068,7 +1068,7 @@ func TestExpiration_RenewToken_period_backend(t *testing.T) {
 		Path:        "auth/foo/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	resp, err := exp.RenewToken(namespace.TestContext(), &logical.Request{}, te, 0)
+	resp, err := exp.RenewToken(namespace.RootContext(nil), &logical.Request{}, te, 0)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1081,7 +1081,7 @@ func TestExpiration_RenewToken_period_backend(t *testing.T) {
 
 	// Wait another 3 seconds. If period works correctly, this should not fail
 	time.Sleep(3 * time.Second)
-	resp, err = exp.RenewToken(namespace.TestContext(), &logical.Request{}, te, 0)
+	resp, err = exp.RenewToken(namespace.RootContext(nil), &logical.Request{}, te, 0)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1113,7 +1113,7 @@ func TestExpiration_RenewToken_NotRenewable(t *testing.T) {
 		Path:        "auth/foo/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1124,7 +1124,7 @@ func TestExpiration_RenewToken_NotRenewable(t *testing.T) {
 		Path:        "auth/github/login",
 		NamespaceID: namespace.RootNamespaceID,
 	}
-	resp, err := exp.RenewToken(namespace.TestContext(), &logical.Request{}, te, 0)
+	resp, err := exp.RenewToken(namespace.RootContext(nil), &logical.Request{}, te, 0)
 	if err != nil && (err != logical.ErrInvalidRequest || (resp != nil && resp.IsError() && resp.Error().Error() != "invalid lease ID")) {
 		t.Fatalf("bad: err:%v resp:%#v", err, resp)
 	}
@@ -1143,7 +1143,7 @@ func TestExpiration_Renew(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1167,7 +1167,7 @@ func TestExpiration_Renew(t *testing.T) {
 		},
 	}
 
-	id, err := exp.Register(namespace.TestContext(), req, resp)
+	id, err := exp.Register(namespace.RootContext(nil), req, resp)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1184,7 +1184,7 @@ func TestExpiration_Renew(t *testing.T) {
 		},
 	}
 
-	out, err := exp.Renew(namespace.TestContext(), id, 0)
+	out, err := exp.Renew(namespace.RootContext(nil), id, 0)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1214,7 +1214,7 @@ func TestExpiration_Renew_NotRenewable(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1238,12 +1238,12 @@ func TestExpiration_Renew_NotRenewable(t *testing.T) {
 		},
 	}
 
-	id, err := exp.Register(namespace.TestContext(), req, resp)
+	id, err := exp.Register(namespace.RootContext(nil), req, resp)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	_, err = exp.Renew(namespace.TestContext(), id, 0)
+	_, err = exp.Renew(namespace.RootContext(nil), id, 0)
 	if err.Error() != "lease is not renewable" {
 		t.Fatalf("err: %v", err)
 	}
@@ -1265,7 +1265,7 @@ func TestExpiration_Renew_RevokeOnExpire(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "prod/aws/", &MountEntry{Path: "prod/aws/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1289,7 +1289,7 @@ func TestExpiration_Renew_RevokeOnExpire(t *testing.T) {
 		},
 	}
 
-	id, err := exp.Register(namespace.TestContext(), req, resp)
+	id, err := exp.Register(namespace.RootContext(nil), req, resp)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1306,7 +1306,7 @@ func TestExpiration_Renew_RevokeOnExpire(t *testing.T) {
 		},
 	}
 
-	_, err = exp.Renew(namespace.TestContext(), id, 0)
+	_, err = exp.Renew(namespace.RootContext(nil), id, 0)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1342,7 +1342,7 @@ func TestExpiration_revokeEntry(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "foo/bar/", &MountEntry{Path: "foo/bar/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "foo/bar/", &MountEntry{Path: "foo/bar/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1360,10 +1360,10 @@ func TestExpiration_revokeEntry(t *testing.T) {
 		},
 		IssueTime:  time.Now(),
 		ExpireTime: time.Now(),
-		namespace:  namespace.TestNamespace(),
+		namespace:  namespace.RootNamespace,
 	}
 
-	err = exp.revokeEntry(namespace.TestContext(), le)
+	err = exp.revokeEntry(namespace.RootContext(nil), le)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1412,18 +1412,18 @@ func TestExpiration_revokeEntry_token(t *testing.T) {
 		Path:        "foo/bar",
 		IssueTime:   time.Now(),
 		ExpireTime:  time.Now(),
-		namespace:   namespace.TestNamespace(),
+		namespace:   namespace.RootNamespace,
 	}
 
-	if err := exp.persistEntry(namespace.TestContext(), le); err != nil {
+	if err := exp.persistEntry(namespace.RootContext(nil), le); err != nil {
 		t.Fatalf("error persisting entry: %v", err)
 	}
-	if err := exp.createIndexByToken(namespace.TestContext(), le, le.ClientToken); err != nil {
+	if err := exp.createIndexByToken(namespace.RootContext(nil), le, le.ClientToken); err != nil {
 		t.Fatalf("error creating secondary index: %v", err)
 	}
 	exp.updatePending(le, le.Secret.LeaseTotal())
 
-	indexEntry, err := exp.indexByToken(namespace.TestContext(), le)
+	indexEntry, err := exp.indexByToken(namespace.RootContext(nil), le)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1431,14 +1431,14 @@ func TestExpiration_revokeEntry_token(t *testing.T) {
 		t.Fatalf("err: should have found a secondary index entry")
 	}
 
-	err = exp.revokeEntry(namespace.TestContext(), le)
+	err = exp.revokeEntry(namespace.RootContext(nil), le)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	time.Sleep(300 * time.Millisecond)
 
-	out, err := exp.tokenStore.Lookup(namespace.TestContext(), le.ClientToken)
+	out, err := exp.tokenStore.Lookup(namespace.RootContext(nil), le.ClientToken)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1446,7 +1446,7 @@ func TestExpiration_revokeEntry_token(t *testing.T) {
 		t.Fatalf("bad: %v", out)
 	}
 
-	indexEntry, err = exp.indexByToken(namespace.TestContext(), le)
+	indexEntry, err = exp.indexByToken(namespace.RootContext(nil), le)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1477,7 +1477,7 @@ func TestExpiration_renewEntry(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "foo/bar/", &MountEntry{Path: "foo/bar/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "foo/bar/", &MountEntry{Path: "foo/bar/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1495,10 +1495,10 @@ func TestExpiration_renewEntry(t *testing.T) {
 		},
 		IssueTime:  time.Now(),
 		ExpireTime: time.Now(),
-		namespace:  namespace.TestNamespace(),
+		namespace:  namespace.RootNamespace,
 	}
 
-	resp, err := exp.renewEntry(namespace.TestContext(), le, 0)
+	resp, err := exp.renewEntry(namespace.RootContext(nil), le, 0)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1543,7 +1543,7 @@ func TestExpiration_revokeEntry_rejected(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "foo/bar/", &MountEntry{Path: "foo/bar/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "foo/bar/", &MountEntry{Path: "foo/bar/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1561,15 +1561,15 @@ func TestExpiration_revokeEntry_rejected(t *testing.T) {
 		},
 		IssueTime:  time.Now(),
 		ExpireTime: time.Now().Add(time.Minute),
-		namespace:  namespace.TestNamespace(),
+		namespace:  namespace.RootNamespace,
 	}
 
-	err = exp.persistEntry(namespace.TestContext(), le)
+	err = exp.persistEntry(namespace.RootContext(nil), le)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = exp.LazyRevoke(namespace.TestContext(), le.LeaseID)
+	err = exp.LazyRevoke(namespace.RootContext(nil), le.LeaseID)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1602,7 +1602,7 @@ func TestExpiration_revokeEntry_rejected(t *testing.T) {
 	// Now let the revocation actually process
 	time.Sleep(1 * time.Second)
 
-	le, err = exp.FetchLeaseTimes(namespace.TestContext(), le.LeaseID)
+	le, err = exp.FetchLeaseTimes(namespace.RootContext(nil), le.LeaseID)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1630,7 +1630,7 @@ func TestExpiration_renewAuthEntry(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	err = exp.router.Mount(noop, "auth/foo/", &MountEntry{Path: "auth/foo/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.TestNamespace()}, view)
+	err = exp.router.Mount(noop, "auth/foo/", &MountEntry{Path: "auth/foo/", Type: "noop", UUID: meUUID, Accessor: "noop-accessor", namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1649,10 +1649,10 @@ func TestExpiration_renewAuthEntry(t *testing.T) {
 		},
 		IssueTime:  time.Now(),
 		ExpireTime: time.Now().Add(time.Minute),
-		namespace:  namespace.TestNamespace(),
+		namespace:  namespace.RootNamespace,
 	}
 
-	resp, err := exp.renewAuthEntry(namespace.TestContext(), &logical.Request{}, le, 0)
+	resp, err := exp.renewAuthEntry(namespace.RootContext(nil), &logical.Request{}, le, 0)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1693,13 +1693,13 @@ func TestExpiration_PersistLoadDelete(t *testing.T) {
 		IssueTime:       lastTime,
 		ExpireTime:      lastTime,
 		LastRenewalTime: lastTime,
-		namespace:       namespace.TestNamespace(),
+		namespace:       namespace.RootNamespace,
 	}
-	if err := exp.persistEntry(namespace.TestContext(), le); err != nil {
+	if err := exp.persistEntry(namespace.RootContext(nil), le); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	out, err := exp.loadEntry(namespace.TestContext(), "foo/bar/1234")
+	out, err := exp.loadEntry(namespace.RootContext(nil), "foo/bar/1234")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1715,12 +1715,12 @@ func TestExpiration_PersistLoadDelete(t *testing.T) {
 		t.Fatalf("bad: expected:\n%#v\nactual:\n%#v", le, out)
 	}
 
-	err = exp.deleteEntry(namespace.TestContext(), le)
+	err = exp.deleteEntry(namespace.RootContext(nil), le)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	out, err = exp.loadEntry(namespace.TestContext(), "foo/bar/1234")
+	out, err = exp.loadEntry(namespace.RootContext(nil), "foo/bar/1234")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1803,7 +1803,7 @@ func TestExpiration_RevokeForce(t *testing.T) {
 		Accessor: "badrenewaccessor",
 	}
 
-	err := core.mount(namespace.TestContext(), me)
+	err := core.mount(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1815,7 +1815,7 @@ func TestExpiration_RevokeForce(t *testing.T) {
 	}
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
 
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1829,13 +1829,13 @@ func TestExpiration_RevokeForce(t *testing.T) {
 	req.Operation = logical.UpdateOperation
 	req.Path = "sys/revoke-prefix/badrenew/creds"
 
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil {
 		t.Fatal("expected error")
 	}
 
 	req.Path = "sys/revoke-force/badrenew/creds"
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("got error: %s", err)
 	}
@@ -1852,7 +1852,7 @@ func TestExpiration_RevokeForceSingle(t *testing.T) {
 		Accessor: "badrenewaccessor",
 	}
 
-	err := core.mount(namespace.TestContext(), me)
+	err := core.mount(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1864,7 +1864,7 @@ func TestExpiration_RevokeForceSingle(t *testing.T) {
 	}
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
 
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1879,7 +1879,7 @@ func TestExpiration_RevokeForceSingle(t *testing.T) {
 	req.Operation = logical.UpdateOperation
 	req.Path = "sys/leases/lookup"
 	req.Data = map[string]interface{}{"lease_id": leaseID}
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1892,20 +1892,20 @@ func TestExpiration_RevokeForceSingle(t *testing.T) {
 
 	req.Path = "sys/revoke-prefix/" + leaseID
 
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil {
 		t.Fatal("expected error")
 	}
 
 	req.Path = "sys/revoke-force/" + leaseID
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("got error: %s", err)
 	}
 
 	req.Path = "sys/leases/lookup"
 	req.Data = map[string]interface{}{"lease_id": leaseID}
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil {
 		t.Fatal("expected error")
 	}
@@ -1945,7 +1945,7 @@ func badRenewFactory(ctx context.Context, conf *logical.BackendConfig) (logical.
 		},
 	}
 
-	err := be.Setup(namespace.TestContext(), conf)
+	err := be.Setup(namespace.RootContext(nil), conf)
 	if err != nil {
 		return nil, err
 	}
diff --git a/vault/identity_store_entities_test.go b/vault/identity_store_entities_test.go
index c90baafc8a..a4c21c9622 100644
--- a/vault/identity_store_entities_test.go
+++ b/vault/identity_store_entities_test.go
@@ -342,8 +342,8 @@ func TestIdentityStore_EntityCreateUpdate(t *testing.T) {
 
 func TestIdentityStore_CloneImmutability(t *testing.T) {
 	alias := &identity.Alias{
-		ID:                     "testaliasid",
-		Name:                   "testaliasname",
+		ID:   "testaliasid",
+		Name: "testaliasname",
 		MergedFromCanonicalIDs: []string{"entityid1"},
 	}
 
@@ -544,7 +544,7 @@ func TestIdentityStore_LoadingEntities(t *testing.T) {
 	}
 
 	// Identity store will be mounted by now, just fetch it from router
-	identitystore := c.router.MatchingBackend(namespace.TestContext(), "identity/")
+	identitystore := c.router.MatchingBackend(namespace.RootContext(nil), "identity/")
 	if identitystore == nil {
 		t.Fatalf("failed to fetch identity store from router")
 	}
diff --git a/vault/identity_store_test.go b/vault/identity_store_test.go
index a6827cdb9f..cf7cd45581 100644
--- a/vault/identity_store_test.go
+++ b/vault/identity_store_test.go
@@ -17,7 +17,7 @@ import (
 
 func TestIdentityStore_EntityIDPassthrough(t *testing.T) {
 	// Enable GitHub auth and initialize
-	ctx := namespace.TestContext()
+	ctx := namespace.RootContext(nil)
 	is, ghAccessor, core := testIdentityStoreWithGithubAuth(ctx, t)
 	alias := &logical.Alias{
 		MountType:     "github",
@@ -322,7 +322,7 @@ func TestIdentityStore_MergeConflictingAliases(t *testing.T) {
 		Description: "github auth",
 	}
 
-	err = c.enableCredential(namespace.TestContext(), meGH)
+	err = c.enableCredential(namespace.RootContext(nil), meGH)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -391,7 +391,7 @@ func TestIdentityStore_MergeConflictingAliases(t *testing.T) {
 		t.Fatal("still sealed")
 	}
 
-	newEntity, err := c.identityStore.CreateOrFetchEntity(namespace.TestContext(), &logical.Alias{
+	newEntity, err := c.identityStore.CreateOrFetchEntity(namespace.RootContext(nil), &logical.Alias{
 		MountAccessor: meGH.Accessor,
 		MountType:     "github",
 		Name:          "githubuser",
diff --git a/vault/logical_system_test.go b/vault/logical_system_test.go
index 017327d9fb..672a6cacd7 100644
--- a/vault/logical_system_test.go
+++ b/vault/logical_system_test.go
@@ -67,7 +67,7 @@ func TestSystemConfigCORS(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "config/cors")
 	req.Data["allowed_origins"] = "http://www.example.com"
 	req.Data["allowed_headers"] = "X-Custom-Header"
-	_, err := b.HandleRequest(namespace.TestContext(), req)
+	_, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -81,7 +81,7 @@ func TestSystemConfigCORS(t *testing.T) {
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "config/cors")
-	actual, err := b.HandleRequest(namespace.TestContext(), req)
+	actual, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -91,13 +91,13 @@ func TestSystemConfigCORS(t *testing.T) {
 	}
 
 	req = logical.TestRequest(t, logical.DeleteOperation, "config/cors")
-	_, err = b.HandleRequest(namespace.TestContext(), req)
+	_, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "config/cors")
-	actual, err = b.HandleRequest(namespace.TestContext(), req)
+	actual, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -117,7 +117,7 @@ func TestSystemConfigCORS(t *testing.T) {
 func TestSystemBackend_mounts(t *testing.T) {
 	b := testSystemBackend(t)
 	req := logical.TestRequest(t, logical.ReadOperation, "mounts")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -204,7 +204,7 @@ func TestSystemBackend_mount(t *testing.T) {
 		"version": "1",
 	}
 
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -213,7 +213,7 @@ func TestSystemBackend_mount(t *testing.T) {
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "mounts")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -311,7 +311,7 @@ func TestSystemBackend_mount_force_no_cache(t *testing.T) {
 		"force_no_cache": true,
 	}
 
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -319,7 +319,7 @@ func TestSystemBackend_mount_force_no_cache(t *testing.T) {
 		t.Fatalf("bad: %v", resp)
 	}
 
-	mountEntry := core.router.MatchingMountEntry(namespace.TestContext(), "prod/secret/")
+	mountEntry := core.router.MatchingMountEntry(namespace.RootContext(nil), "prod/secret/")
 	if mountEntry == nil {
 		t.Fatalf("missing mount entry")
 	}
@@ -333,7 +333,7 @@ func TestSystemBackend_mount_invalid(t *testing.T) {
 
 	req := logical.TestRequest(t, logical.UpdateOperation, "mounts/prod/secret/")
 	req.Data["type"] = "nope"
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -346,7 +346,7 @@ func TestSystemBackend_unmount(t *testing.T) {
 	b := testSystemBackend(t)
 
 	req := logical.TestRequest(t, logical.DeleteOperation, "mounts/secret/")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -378,7 +378,7 @@ func TestSystemBackend_PathCapabilities(t *testing.T) {
 	core, b, rootToken := testCoreSystemBackend(t)
 
 	policy, _ := ParseACLPolicy(namespace.RootNamespace, capabilitiesPolicy)
-	err = core.policyStore.SetPolicy(namespace.TestContext(), policy)
+	err = core.policyStore.SetPolicy(namespace.RootContext(nil), policy)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -400,7 +400,7 @@ func TestSystemBackend_PathCapabilities(t *testing.T) {
 	}
 
 	// Check the capabilities using the root token
-	resp, err = b.HandleRequest(namespace.TestContext(), &logical.Request{
+	resp, err = b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 		Path:      "capabilities",
 		Operation: logical.UpdateOperation,
 		Data: map[string]interface{}{
@@ -414,7 +414,7 @@ func TestSystemBackend_PathCapabilities(t *testing.T) {
 	rootCheckFunc(t, resp)
 
 	// Check the capabilities using capabilities-self
-	resp, err = b.HandleRequest(namespace.TestContext(), &logical.Request{
+	resp, err = b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 		ClientToken: rootToken,
 		Path:        "capabilities-self",
 		Operation:   logical.UpdateOperation,
@@ -428,13 +428,13 @@ func TestSystemBackend_PathCapabilities(t *testing.T) {
 	rootCheckFunc(t, resp)
 
 	// Lookup the accessor of the root token
-	te, err := core.tokenStore.Lookup(namespace.TestContext(), rootToken)
+	te, err := core.tokenStore.Lookup(namespace.RootContext(nil), rootToken)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	// Check the capabilities using capabilities-accessor endpoint
-	resp, err = b.HandleRequest(namespace.TestContext(), &logical.Request{
+	resp, err = b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 		Path:      "capabilities-accessor",
 		Operation: logical.UpdateOperation,
 		Data: map[string]interface{}{
@@ -465,7 +465,7 @@ func TestSystemBackend_PathCapabilities(t *testing.T) {
 	}
 
 	// Check the capabilities using a non-root token
-	resp, err = b.HandleRequest(namespace.TestContext(), &logical.Request{
+	resp, err = b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 		Path:      "capabilities",
 		Operation: logical.UpdateOperation,
 		Data: map[string]interface{}{
@@ -480,7 +480,7 @@ func TestSystemBackend_PathCapabilities(t *testing.T) {
 
 	// Check the capabilities of a non-root token using capabilities-self
 	// endpoint
-	resp, err = b.HandleRequest(namespace.TestContext(), &logical.Request{
+	resp, err = b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 		ClientToken: "tokenid",
 		Path:        "capabilities-self",
 		Operation:   logical.UpdateOperation,
@@ -494,14 +494,14 @@ func TestSystemBackend_PathCapabilities(t *testing.T) {
 	nonRootCheckFunc(t, resp)
 
 	// Lookup the accessor of the non-root token
-	te, err = core.tokenStore.Lookup(namespace.TestContext(), "tokenid")
+	te, err = core.tokenStore.Lookup(namespace.RootContext(nil), "tokenid")
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	// Check the capabilities using a non-root token using
 	// capabilities-accessor endpoint
-	resp, err = b.HandleRequest(namespace.TestContext(), &logical.Request{
+	resp, err = b.HandleRequest(namespace.RootContext(nil), &logical.Request{
 		Path:      "capabilities-accessor",
 		Operation: logical.UpdateOperation,
 		Data: map[string]interface{}{
@@ -530,7 +530,7 @@ func testCapabilities(t *testing.T, endpoint string) {
 	}
 	req.Data["path"] = "any_path"
 
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -545,7 +545,7 @@ func testCapabilities(t *testing.T, endpoint string) {
 	}
 
 	policy, _ := ParseACLPolicy(namespace.RootNamespace, capabilitiesPolicy)
-	err = core.policyStore.SetPolicy(namespace.TestContext(), policy)
+	err = core.policyStore.SetPolicy(namespace.RootContext(nil), policy)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -559,7 +559,7 @@ func testCapabilities(t *testing.T, endpoint string) {
 	}
 	req.Data["path"] = "foo/bar"
 
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -576,7 +576,7 @@ func testCapabilities(t *testing.T, endpoint string) {
 
 func TestSystemBackend_CapabilitiesAccessor_BC(t *testing.T) {
 	core, b, rootToken := testCoreSystemBackend(t)
-	te, err := core.tokenStore.Lookup(namespace.TestContext(), rootToken)
+	te, err := core.tokenStore.Lookup(namespace.RootContext(nil), rootToken)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -586,7 +586,7 @@ func TestSystemBackend_CapabilitiesAccessor_BC(t *testing.T) {
 	req.Data["accessor"] = te.Accessor
 	req.Data["path"] = "any_path"
 
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -601,14 +601,14 @@ func TestSystemBackend_CapabilitiesAccessor_BC(t *testing.T) {
 	}
 
 	policy, _ := ParseACLPolicy(namespace.RootNamespace, capabilitiesPolicy)
-	err = core.policyStore.SetPolicy(namespace.TestContext(), policy)
+	err = core.policyStore.SetPolicy(namespace.RootContext(nil), policy)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	testMakeServiceTokenViaBackend(t, core.tokenStore, rootToken, "tokenid", "", []string{"test"})
 
-	te, err = core.tokenStore.Lookup(namespace.TestContext(), "tokenid")
+	te, err = core.tokenStore.Lookup(namespace.RootContext(nil), "tokenid")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -617,7 +617,7 @@ func TestSystemBackend_CapabilitiesAccessor_BC(t *testing.T) {
 	req.Data["accessor"] = te.Accessor
 	req.Data["path"] = "foo/bar"
 
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -639,7 +639,7 @@ func TestSystemBackend_remount(t *testing.T) {
 	req.Data["from"] = "secret"
 	req.Data["to"] = "foo"
 	req.Data["config"] = structs.Map(MountConfig{})
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -655,7 +655,7 @@ func TestSystemBackend_remount_invalid(t *testing.T) {
 	req.Data["from"] = "unknown"
 	req.Data["to"] = "foo"
 	req.Data["config"] = structs.Map(MountConfig{})
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -670,7 +670,7 @@ func TestSystemBackend_remount_system(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "remount")
 	req.Data["from"] = "sys"
 	req.Data["to"] = "foo"
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -686,7 +686,7 @@ func TestSystemBackend_leases(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "secret/foo")
 	req.Data["foo"] = "bar"
 	req.ClientToken = root
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -698,7 +698,7 @@ func TestSystemBackend_leases(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -709,7 +709,7 @@ func TestSystemBackend_leases(t *testing.T) {
 	// Read lease
 	req = logical.TestRequest(t, logical.UpdateOperation, "leases/lookup")
 	req.Data["lease_id"] = resp.Secret.LeaseID
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -720,7 +720,7 @@ func TestSystemBackend_leases(t *testing.T) {
 	// Invalid lease
 	req = logical.TestRequest(t, logical.UpdateOperation, "leases/lookup")
 	req.Data["lease_id"] = "invalid"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("expected invalid request, got err: %v", err)
 	}
@@ -733,7 +733,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "secret/foo")
 	req.Data["foo"] = "bar"
 	req.ClientToken = root
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -745,7 +745,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -755,7 +755,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 
 	// List top level
 	req = logical.TestRequest(t, logical.ListOperation, "leases/lookup/")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -775,7 +775,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 
 	// List lease
 	req = logical.TestRequest(t, logical.ListOperation, "leases/lookup/secret/foo")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -794,7 +794,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -805,7 +805,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -814,7 +814,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 	}
 
 	req = logical.TestRequest(t, logical.ListOperation, "leases/lookup/secret/foo")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -833,7 +833,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 	req = logical.TestRequest(t, logical.UpdateOperation, "secret/bar")
 	req.Data["foo"] = "bar"
 	req.ClientToken = root
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -845,7 +845,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/bar")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -854,7 +854,7 @@ func TestSystemBackend_leases_list(t *testing.T) {
 	}
 
 	req = logical.TestRequest(t, logical.ListOperation, "leases/lookup/secret")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -881,7 +881,7 @@ func TestSystemBackend_renew(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "secret/foo")
 	req.Data["foo"] = "bar"
 	req.ClientToken = root
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -893,7 +893,7 @@ func TestSystemBackend_renew(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -903,7 +903,7 @@ func TestSystemBackend_renew(t *testing.T) {
 
 	// Attempt renew
 	req2 := logical.TestRequest(t, logical.UpdateOperation, "leases/renew/"+resp.Secret.LeaseID)
-	resp2, err := b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err := b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -918,7 +918,7 @@ func TestSystemBackend_renew(t *testing.T) {
 	req.Data["foo"] = "bar"
 	req.Data["ttl"] = "180s"
 	req.ClientToken = root
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -930,7 +930,7 @@ func TestSystemBackend_renew(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -940,7 +940,7 @@ func TestSystemBackend_renew(t *testing.T) {
 
 	// Attempt renew
 	req2 = logical.TestRequest(t, logical.UpdateOperation, "leases/renew/"+resp.Secret.LeaseID)
-	resp2, err = b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err = b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -957,7 +957,7 @@ func TestSystemBackend_renew(t *testing.T) {
 	// Test the other route path
 	req2 = logical.TestRequest(t, logical.UpdateOperation, "leases/renew")
 	req2.Data["lease_id"] = resp.Secret.LeaseID
-	resp2, err = b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err = b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -974,7 +974,7 @@ func TestSystemBackend_renew(t *testing.T) {
 	// Test orig path
 	req2 = logical.TestRequest(t, logical.UpdateOperation, "renew")
 	req2.Data["lease_id"] = resp.Secret.LeaseID
-	resp2, err = b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err = b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -994,7 +994,7 @@ func TestSystemBackend_renew_invalidID(t *testing.T) {
 
 	// Attempt renew
 	req := logical.TestRequest(t, logical.UpdateOperation, "leases/renew/foobarbaz")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1005,7 +1005,7 @@ func TestSystemBackend_renew_invalidID(t *testing.T) {
 	// Attempt renew with other method
 	req = logical.TestRequest(t, logical.UpdateOperation, "leases/renew")
 	req.Data["lease_id"] = "foobarbaz"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1019,7 +1019,7 @@ func TestSystemBackend_renew_invalidID_origUrl(t *testing.T) {
 
 	// Attempt renew
 	req := logical.TestRequest(t, logical.UpdateOperation, "renew/foobarbaz")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1030,7 +1030,7 @@ func TestSystemBackend_renew_invalidID_origUrl(t *testing.T) {
 	// Attempt renew with other method
 	req = logical.TestRequest(t, logical.UpdateOperation, "renew")
 	req.Data["lease_id"] = "foobarbaz"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1047,7 +1047,7 @@ func TestSystemBackend_revoke(t *testing.T) {
 	req.Data["foo"] = "bar"
 	req.Data["lease"] = "1h"
 	req.ClientToken = root
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1059,7 +1059,7 @@ func TestSystemBackend_revoke(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1069,7 +1069,7 @@ func TestSystemBackend_revoke(t *testing.T) {
 
 	// Attempt revoke
 	req2 := logical.TestRequest(t, logical.UpdateOperation, "revoke/"+resp.Secret.LeaseID)
-	resp2, err := b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err := b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != nil {
 		t.Fatalf("err: %v %#v", err, resp2)
 	}
@@ -1079,7 +1079,7 @@ func TestSystemBackend_revoke(t *testing.T) {
 
 	// Attempt renew
 	req3 := logical.TestRequest(t, logical.UpdateOperation, "renew/"+resp.Secret.LeaseID)
-	resp3, err := b.HandleRequest(namespace.TestContext(), req3)
+	resp3, err := b.HandleRequest(namespace.RootContext(nil), req3)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1091,7 +1091,7 @@ func TestSystemBackend_revoke(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1102,7 +1102,7 @@ func TestSystemBackend_revoke(t *testing.T) {
 	// Test the other route path
 	req2 = logical.TestRequest(t, logical.UpdateOperation, "revoke")
 	req2.Data["lease_id"] = resp.Secret.LeaseID
-	resp2, err = b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err = b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != nil {
 		t.Fatalf("err: %v %#v", err, resp2)
 	}
@@ -1114,7 +1114,7 @@ func TestSystemBackend_revoke(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1125,7 +1125,7 @@ func TestSystemBackend_revoke(t *testing.T) {
 	// Test the other route path
 	req2 = logical.TestRequest(t, logical.UpdateOperation, "leases/revoke")
 	req2.Data["lease_id"] = resp.Secret.LeaseID
-	resp2, err = b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err = b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != nil {
 		t.Fatalf("err: %v %#v", err, resp2)
 	}
@@ -1139,7 +1139,7 @@ func TestSystemBackend_revoke_invalidID(t *testing.T) {
 
 	// Attempt revoke
 	req := logical.TestRequest(t, logical.UpdateOperation, "leases/revoke/foobarbaz")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1150,7 +1150,7 @@ func TestSystemBackend_revoke_invalidID(t *testing.T) {
 	// Attempt revoke with other method
 	req = logical.TestRequest(t, logical.UpdateOperation, "leases/revoke")
 	req.Data["lease_id"] = "foobarbaz"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1164,7 +1164,7 @@ func TestSystemBackend_revoke_invalidID_origUrl(t *testing.T) {
 
 	// Attempt revoke
 	req := logical.TestRequest(t, logical.UpdateOperation, "revoke/foobarbaz")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1175,7 +1175,7 @@ func TestSystemBackend_revoke_invalidID_origUrl(t *testing.T) {
 	// Attempt revoke with other method
 	req = logical.TestRequest(t, logical.UpdateOperation, "revoke")
 	req.Data["lease_id"] = "foobarbaz"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1192,7 +1192,7 @@ func TestSystemBackend_revokePrefix(t *testing.T) {
 	req.Data["foo"] = "bar"
 	req.Data["lease"] = "1h"
 	req.ClientToken = root
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1204,7 +1204,7 @@ func TestSystemBackend_revokePrefix(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1214,7 +1214,7 @@ func TestSystemBackend_revokePrefix(t *testing.T) {
 
 	// Attempt revoke
 	req2 := logical.TestRequest(t, logical.UpdateOperation, "leases/revoke-prefix/secret/")
-	resp2, err := b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err := b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != nil {
 		t.Fatalf("err: %v %#v", err, resp2)
 	}
@@ -1224,7 +1224,7 @@ func TestSystemBackend_revokePrefix(t *testing.T) {
 
 	// Attempt renew
 	req3 := logical.TestRequest(t, logical.UpdateOperation, "leases/renew/"+resp.Secret.LeaseID)
-	resp3, err := b.HandleRequest(namespace.TestContext(), req3)
+	resp3, err := b.HandleRequest(namespace.RootContext(nil), req3)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1241,7 +1241,7 @@ func TestSystemBackend_revokePrefix_origUrl(t *testing.T) {
 	req.Data["foo"] = "bar"
 	req.Data["lease"] = "1h"
 	req.ClientToken = root
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1253,7 +1253,7 @@ func TestSystemBackend_revokePrefix_origUrl(t *testing.T) {
 	req = logical.TestRequest(t, logical.ReadOperation, "secret/foo")
 	req.ClientToken = root
 	req.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1263,7 +1263,7 @@ func TestSystemBackend_revokePrefix_origUrl(t *testing.T) {
 
 	// Attempt revoke
 	req2 := logical.TestRequest(t, logical.UpdateOperation, "revoke-prefix/secret/")
-	resp2, err := b.HandleRequest(namespace.TestContext(), req2)
+	resp2, err := b.HandleRequest(namespace.RootContext(nil), req2)
 	if err != nil {
 		t.Fatalf("err: %v %#v", err, resp2)
 	}
@@ -1273,7 +1273,7 @@ func TestSystemBackend_revokePrefix_origUrl(t *testing.T) {
 
 	// Attempt renew
 	req3 := logical.TestRequest(t, logical.UpdateOperation, "renew/"+resp.Secret.LeaseID)
-	resp3, err := b.HandleRequest(namespace.TestContext(), req3)
+	resp3, err := b.HandleRequest(namespace.RootContext(nil), req3)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1294,7 +1294,7 @@ func TestSystemBackend_revokePrefixAuth_newUrl(t *testing.T) {
 		},
 	}
 	b := NewSystemBackend(core, hclog.New(&hclog.LoggerOptions{}))
-	err := b.Backend.Setup(namespace.TestContext(), bc)
+	err := b.Backend.Setup(namespace.RootContext(nil), bc)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1309,7 +1309,7 @@ func TestSystemBackend_revokePrefixAuth_newUrl(t *testing.T) {
 	}
 	testMakeTokenDirectly(t, ts, te)
 
-	te, err = ts.Lookup(namespace.TestContext(), "foo")
+	te, err = ts.Lookup(namespace.RootContext(nil), "foo")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1324,13 +1324,13 @@ func TestSystemBackend_revokePrefixAuth_newUrl(t *testing.T) {
 			TTL: time.Hour,
 		},
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	req := logical.TestRequest(t, logical.UpdateOperation, "leases/revoke-prefix/auth/github/")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v %v", err, resp)
 	}
@@ -1338,7 +1338,7 @@ func TestSystemBackend_revokePrefixAuth_newUrl(t *testing.T) {
 		t.Fatalf("bad: %#v", resp)
 	}
 
-	te, err = ts.Lookup(namespace.TestContext(), te.ID)
+	te, err = ts.Lookup(namespace.RootContext(nil), te.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1358,7 +1358,7 @@ func TestSystemBackend_revokePrefixAuth_origUrl(t *testing.T) {
 		},
 	}
 	b := NewSystemBackend(core, hclog.New(&hclog.LoggerOptions{}))
-	err := b.Backend.Setup(namespace.TestContext(), bc)
+	err := b.Backend.Setup(namespace.RootContext(nil), bc)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1373,7 +1373,7 @@ func TestSystemBackend_revokePrefixAuth_origUrl(t *testing.T) {
 	}
 	testMakeTokenDirectly(t, ts, te)
 
-	te, err = ts.Lookup(namespace.TestContext(), "foo")
+	te, err = ts.Lookup(namespace.RootContext(nil), "foo")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1388,13 +1388,13 @@ func TestSystemBackend_revokePrefixAuth_origUrl(t *testing.T) {
 			TTL: time.Hour,
 		},
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	req := logical.TestRequest(t, logical.UpdateOperation, "revoke-prefix/auth/github/")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v %v", err, resp)
 	}
@@ -1402,7 +1402,7 @@ func TestSystemBackend_revokePrefixAuth_origUrl(t *testing.T) {
 		t.Fatalf("bad: %#v", resp)
 	}
 
-	te, err = ts.Lookup(namespace.TestContext(), te.ID)
+	te, err = ts.Lookup(namespace.RootContext(nil), te.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1414,7 +1414,7 @@ func TestSystemBackend_revokePrefixAuth_origUrl(t *testing.T) {
 func TestSystemBackend_authTable(t *testing.T) {
 	b := testSystemBackend(t)
 	req := logical.TestRequest(t, logical.ReadOperation, "auth")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1456,7 +1456,7 @@ func TestSystemBackend_enableAuth(t *testing.T) {
 	req.Data["local"] = true
 	req.Data["seal_wrap"] = true
 
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1465,7 +1465,7 @@ func TestSystemBackend_enableAuth(t *testing.T) {
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "auth")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1514,7 +1514,7 @@ func TestSystemBackend_enableAuth_invalid(t *testing.T) {
 	b := testSystemBackend(t)
 	req := logical.TestRequest(t, logical.UpdateOperation, "auth/foo")
 	req.Data["type"] = "nope"
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1532,11 +1532,11 @@ func TestSystemBackend_disableAuth(t *testing.T) {
 	// Register the backend
 	req := logical.TestRequest(t, logical.UpdateOperation, "auth/foo")
 	req.Data["type"] = "noop"
-	b.HandleRequest(namespace.TestContext(), req)
+	b.HandleRequest(namespace.RootContext(nil), req)
 
 	// Deregister it
 	req = logical.TestRequest(t, logical.DeleteOperation, "auth/foo")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1548,7 +1548,7 @@ func TestSystemBackend_disableAuth(t *testing.T) {
 func TestSystemBackend_policyList(t *testing.T) {
 	b := testSystemBackend(t)
 	req := logical.TestRequest(t, logical.ReadOperation, "policy")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1569,7 +1569,7 @@ func TestSystemBackend_policyCRUD(t *testing.T) {
 	rules := `path "foo/" { policy = "read" }`
 	req := logical.TestRequest(t, logical.UpdateOperation, "policy/Foo")
 	req.Data["rules"] = rules
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v %#v", err, resp)
 	}
@@ -1579,7 +1579,7 @@ func TestSystemBackend_policyCRUD(t *testing.T) {
 
 	// Read the policy
 	req = logical.TestRequest(t, logical.ReadOperation, "policy/foo")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1594,7 +1594,7 @@ func TestSystemBackend_policyCRUD(t *testing.T) {
 
 	// Read, and make sure that case has been normalized
 	req = logical.TestRequest(t, logical.ReadOperation, "policy/Foo")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1609,7 +1609,7 @@ func TestSystemBackend_policyCRUD(t *testing.T) {
 
 	// List the policies
 	req = logical.TestRequest(t, logical.ReadOperation, "policy")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1624,7 +1624,7 @@ func TestSystemBackend_policyCRUD(t *testing.T) {
 
 	// Delete the policy
 	req = logical.TestRequest(t, logical.DeleteOperation, "policy/foo")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1634,7 +1634,7 @@ func TestSystemBackend_policyCRUD(t *testing.T) {
 
 	// Read the policy (deleted)
 	req = logical.TestRequest(t, logical.ReadOperation, "policy/foo")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1644,7 +1644,7 @@ func TestSystemBackend_policyCRUD(t *testing.T) {
 
 	// List the policies (deleted)
 	req = logical.TestRequest(t, logical.ReadOperation, "policy")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1669,7 +1669,7 @@ func TestSystemBackend_enableAudit(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "audit/foo")
 	req.Data["type"] = "noop"
 
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1682,7 +1682,7 @@ func TestSystemBackend_auditHash(t *testing.T) {
 	c, b, _ := testCoreSystemBackend(t)
 	c.auditBackends["noop"] = func(ctx context.Context, config *audit.BackendConfig) (audit.Backend, error) {
 		view := &logical.InmemStorage{}
-		view.Put(namespace.TestContext(), &logical.StorageEntry{
+		view.Put(namespace.RootContext(nil), &logical.StorageEntry{
 			Key:   "salt",
 			Value: []byte("foo"),
 		})
@@ -1700,7 +1700,7 @@ func TestSystemBackend_auditHash(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "audit/foo")
 	req.Data["type"] = "noop"
 
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1711,7 +1711,7 @@ func TestSystemBackend_auditHash(t *testing.T) {
 	req = logical.TestRequest(t, logical.UpdateOperation, "audit-hash/foo")
 	req.Data["input"] = "bar"
 
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1731,7 +1731,7 @@ func TestSystemBackend_enableAudit_invalid(t *testing.T) {
 	b := testSystemBackend(t)
 	req := logical.TestRequest(t, logical.UpdateOperation, "audit/foo")
 	req.Data["type"] = "nope"
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1755,10 +1755,10 @@ func TestSystemBackend_auditTable(t *testing.T) {
 		"foo": "bar",
 	}
 	req.Data["local"] = true
-	b.HandleRequest(namespace.TestContext(), req)
+	b.HandleRequest(namespace.RootContext(nil), req)
 
 	req = logical.TestRequest(t, logical.ReadOperation, "audit")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1793,11 +1793,11 @@ func TestSystemBackend_disableAudit(t *testing.T) {
 	req.Data["options"] = map[string]interface{}{
 		"foo": "bar",
 	}
-	b.HandleRequest(namespace.TestContext(), req)
+	b.HandleRequest(namespace.RootContext(nil), req)
 
 	// Deregister it
 	req = logical.TestRequest(t, logical.DeleteOperation, "audit/foo")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1810,7 +1810,7 @@ func TestSystemBackend_rawRead_Compressed(t *testing.T) {
 	b := testSystemBackendRaw(t)
 
 	req := logical.TestRequest(t, logical.ReadOperation, "raw/core/mounts")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1823,7 +1823,7 @@ func TestSystemBackend_rawRead_Protected(t *testing.T) {
 	b := testSystemBackendRaw(t)
 
 	req := logical.TestRequest(t, logical.ReadOperation, "raw/"+keyringPath)
-	_, err := b.HandleRequest(namespace.TestContext(), req)
+	_, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1833,7 +1833,7 @@ func TestSystemBackend_rawWrite_Protected(t *testing.T) {
 	b := testSystemBackendRaw(t)
 
 	req := logical.TestRequest(t, logical.UpdateOperation, "raw/"+keyringPath)
-	_, err := b.HandleRequest(namespace.TestContext(), req)
+	_, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1844,7 +1844,7 @@ func TestSystemBackend_rawReadWrite(t *testing.T) {
 
 	req := logical.TestRequest(t, logical.UpdateOperation, "raw/sys/policy/test")
 	req.Data["value"] = `path "secret/" { policy = "read" }`
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1854,7 +1854,7 @@ func TestSystemBackend_rawReadWrite(t *testing.T) {
 
 	// Read via raw API
 	req = logical.TestRequest(t, logical.ReadOperation, "raw/sys/policy/test")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1870,7 +1870,7 @@ func TestSystemBackend_rawDelete_Protected(t *testing.T) {
 	b := testSystemBackendRaw(t)
 
 	req := logical.TestRequest(t, logical.DeleteOperation, "raw/"+keyringPath)
-	_, err := b.HandleRequest(namespace.TestContext(), req)
+	_, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v", err)
 	}
@@ -1885,14 +1885,14 @@ func TestSystemBackend_rawDelete(t *testing.T) {
 		Type:      PolicyTypeACL,
 		namespace: namespace.RootNamespace,
 	}
-	err := c.policyStore.SetPolicy(namespace.TestContext(), p)
+	err := c.policyStore.SetPolicy(namespace.RootContext(nil), p)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Delete the policy
 	req := logical.TestRequest(t, logical.DeleteOperation, "raw/sys/policy/test")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1902,7 +1902,7 @@ func TestSystemBackend_rawDelete(t *testing.T) {
 
 	// Policy should be gone
 	c.policyStore.tokenPoliciesLRU.Purge()
-	out, err := c.policyStore.GetPolicy(namespace.TestContext(), "test", PolicyTypeToken)
+	out, err := c.policyStore.GetPolicy(namespace.RootContext(nil), "test", PolicyTypeToken)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1914,7 +1914,7 @@ func TestSystemBackend_rawDelete(t *testing.T) {
 func TestSystemBackend_keyStatus(t *testing.T) {
 	b := testSystemBackend(t)
 	req := logical.TestRequest(t, logical.ReadOperation, "key-status")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1932,7 +1932,7 @@ func TestSystemBackend_rotate(t *testing.T) {
 	b := testSystemBackend(t)
 
 	req := logical.TestRequest(t, logical.UpdateOperation, "rotate")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1941,7 +1941,7 @@ func TestSystemBackend_rotate(t *testing.T) {
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "key-status")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1985,7 +1985,7 @@ func TestSystemBackend_PluginCatalog_CRUD(t *testing.T) {
 	c.pluginCatalog.directory = sym
 
 	req := logical.TestRequest(t, logical.ListOperation, "plugins/catalog/")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1995,7 +1995,7 @@ func TestSystemBackend_PluginCatalog_CRUD(t *testing.T) {
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "plugins/catalog/mysql-database-plugin")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2025,7 +2025,7 @@ func TestSystemBackend_PluginCatalog_CRUD(t *testing.T) {
 	req.Data["args"] = []string{"--foo"}
 	req.Data["sha_256"] = hex.EncodeToString([]byte{'1'})
 	req.Data["command"] = command
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2034,13 +2034,13 @@ func TestSystemBackend_PluginCatalog_CRUD(t *testing.T) {
 	}
 
 	delete(req.Data, "args")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || resp.Error() != nil {
 		t.Fatalf("err: %v %v", err, resp.Error())
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "plugins/catalog/test-plugin")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2059,13 +2059,13 @@ func TestSystemBackend_PluginCatalog_CRUD(t *testing.T) {
 
 	// Delete plugin
 	req = logical.TestRequest(t, logical.DeleteOperation, "plugins/catalog/test-plugin")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "plugins/catalog/test-plugin")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if resp != nil || err != nil {
 		t.Fatalf("expected nil response, plugin not deleted correctly got resp: %v, err: %v", resp, err)
 	}
@@ -2077,14 +2077,14 @@ func TestSystemBackend_ToolsHash(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"input": "dGhlIHF1aWNrIGJyb3duIGZveA==",
 	}
-	_, err := b.HandleRequest(namespace.TestContext(), req)
+	_, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	doRequest := func(req *logical.Request, errExpected bool, expected string) {
 		t.Helper()
-		resp, err := b.HandleRequest(namespace.TestContext(), req)
+		resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil && !errExpected {
 			t.Fatal(err)
 		}
@@ -2148,7 +2148,7 @@ func TestSystemBackend_ToolsRandom(t *testing.T) {
 	b := testSystemBackend(t)
 	req := logical.TestRequest(t, logical.UpdateOperation, "tools/random")
 
-	_, err := b.HandleRequest(namespace.TestContext(), req)
+	_, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2156,7 +2156,7 @@ func TestSystemBackend_ToolsRandom(t *testing.T) {
 	doRequest := func(req *logical.Request, errExpected bool, format string, numBytes int) {
 		t.Helper()
 		getResponse := func() []byte {
-			resp, err := b.HandleRequest(namespace.TestContext(), req)
+			resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 			if err != nil && !errExpected {
 				t.Fatal(err)
 			}
@@ -2230,7 +2230,7 @@ func TestSystemBackend_InternalUIMounts(t *testing.T) {
 
 	// Ensure no entries are in the endpoint as a starting point
 	req := logical.TestRequest(t, logical.ReadOperation, "internal/ui/mounts")
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2245,7 +2245,7 @@ func TestSystemBackend_InternalUIMounts(t *testing.T) {
 
 	req = logical.TestRequest(t, logical.ReadOperation, "internal/ui/mounts")
 	req.ClientToken = rootToken
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2336,7 +2336,7 @@ func TestSystemBackend_InternalUIMounts(t *testing.T) {
 	// Mount-tune an auth mount
 	req = logical.TestRequest(t, logical.UpdateOperation, "auth/token/tune")
 	req.Data["listing_visibility"] = "unauth"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if resp.IsError() || err != nil {
 		t.Fatalf("resp.Error: %v, err:%v", resp.Error(), err)
 	}
@@ -2344,13 +2344,13 @@ func TestSystemBackend_InternalUIMounts(t *testing.T) {
 	// Mount-tune a secret mount
 	req = logical.TestRequest(t, logical.UpdateOperation, "mounts/secret/tune")
 	req.Data["listing_visibility"] = "unauth"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if resp.IsError() || err != nil {
 		t.Fatalf("resp.Error: %v, err:%v", resp.Error(), err)
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "internal/ui/mounts")
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2386,7 +2386,7 @@ func TestSystemBackend_InternalUIMount(t *testing.T) {
     capabilities = ["create", "read", "update", "delete", "list"]
 }`,
 	}
-	resp, err := b.HandleRequest(namespace.TestContext(), req)
+	resp, err := b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("Bad %#v %#v", err, resp)
 	}
@@ -2396,14 +2396,14 @@ func TestSystemBackend_InternalUIMount(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"type": "kv",
 	}
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("Bad %#v %#v", err, resp)
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "internal/ui/mounts/kv/bar")
 	req.ClientToken = rootToken
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("Bad %#v %#v", err, resp)
 	}
@@ -2415,14 +2415,14 @@ func TestSystemBackend_InternalUIMount(t *testing.T) {
 
 	req = logical.TestRequest(t, logical.ReadOperation, "internal/ui/mounts/kv")
 	req.ClientToken = "tokenid"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrPermissionDenied {
 		t.Fatal("expected permission denied error")
 	}
 
 	req = logical.TestRequest(t, logical.ReadOperation, "internal/ui/mounts/secret")
 	req.ClientToken = "tokenid"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("Bad %#v %#v", err, resp)
 	}
@@ -2432,7 +2432,7 @@ func TestSystemBackend_InternalUIMount(t *testing.T) {
 
 	req = logical.TestRequest(t, logical.ReadOperation, "internal/ui/mounts/sys")
 	req.ClientToken = "tokenid"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("Bad %#v %#v", err, resp)
 	}
@@ -2442,7 +2442,7 @@ func TestSystemBackend_InternalUIMount(t *testing.T) {
 
 	req = logical.TestRequest(t, logical.ReadOperation, "internal/ui/mounts/non-existent")
 	req.ClientToken = "tokenid"
-	resp, err = b.HandleRequest(namespace.TestContext(), req)
+	resp, err = b.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrPermissionDenied {
 		t.Fatal("expected permission denied error")
 	}
diff --git a/vault/mount_test.go b/vault/mount_test.go
index 2978c743e9..b3009f7bb3 100644
--- a/vault/mount_test.go
+++ b/vault/mount_test.go
@@ -33,7 +33,7 @@ func TestMount_ReadOnlyViewDuringMount(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err := c.mount(namespace.TestContext(), me)
+	err := c.mount(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -75,12 +75,12 @@ func TestCore_Mount(t *testing.T) {
 		Path:  "foo",
 		Type:  "kv",
 	}
-	err := c.mount(namespace.TestContext(), me)
+	err := c.mount(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	match := c.router.MatchingMount(namespace.TestContext(), "foo/bar")
+	match := c.router.MatchingMount(namespace.RootContext(nil), "foo/bar")
 	if match != "foo/" {
 		t.Fatalf("missing mount")
 	}
@@ -142,7 +142,7 @@ func TestCore_Mount_Local(t *testing.T) {
 	}
 
 	// Both should set up successfully
-	err := c.setupMounts(namespace.TestContext())
+	err := c.setupMounts(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -213,12 +213,12 @@ func TestCore_Mount_Local(t *testing.T) {
 
 func TestCore_Unmount(t *testing.T) {
 	c, keys, _ := TestCoreUnsealed(t)
-	err := c.unmount(namespace.TestContext(), "secret")
+	err := c.unmount(namespace.RootContext(nil), "secret")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	match := c.router.MatchingMount(namespace.TestContext(), "secret/foo")
+	match := c.router.MatchingMount(namespace.RootContext(nil), "secret/foo")
 	if match != "" {
 		t.Fatalf("backend present")
 	}
@@ -260,12 +260,12 @@ func TestCore_Unmount_Cleanup(t *testing.T) {
 		Path:  "test/",
 		Type:  "noop",
 	}
-	if err := c.mount(namespace.TestContext(), me); err != nil {
+	if err := c.mount(namespace.RootContext(nil), me); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Store the view
-	view := c.router.MatchingStorageByAPIPath(namespace.TestContext(), "test/")
+	view := c.router.MatchingStorageByAPIPath(namespace.RootContext(nil), "test/")
 
 	// Inject data
 	se := &logical.StorageEntry{
@@ -296,7 +296,7 @@ func TestCore_Unmount_Cleanup(t *testing.T) {
 		ClientToken: root,
 	}
 	r.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err := c.HandleRequest(namespace.TestContext(), r)
+	resp, err := c.HandleRequest(namespace.RootContext(nil), r)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -305,7 +305,7 @@ func TestCore_Unmount_Cleanup(t *testing.T) {
 	}
 
 	// Unmount, this should cleanup
-	if err := c.unmount(namespace.TestContext(), "test/"); err != nil {
+	if err := c.unmount(namespace.RootContext(nil), "test/"); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -334,12 +334,12 @@ func TestCore_Unmount_Cleanup(t *testing.T) {
 
 func TestCore_Remount(t *testing.T) {
 	c, keys, _ := TestCoreUnsealed(t)
-	err := c.remount(namespace.TestContext(), "secret", "foo")
+	err := c.remount(namespace.RootContext(nil), "secret", "foo")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	match := c.router.MatchingMount(namespace.TestContext(), "foo/bar")
+	match := c.router.MatchingMount(namespace.RootContext(nil), "foo/bar")
 	if match != "foo/" {
 		t.Fatalf("failed remount")
 	}
@@ -381,12 +381,12 @@ func TestCore_Remount_Cleanup(t *testing.T) {
 		Path:  "test/",
 		Type:  "noop",
 	}
-	if err := c.mount(namespace.TestContext(), me); err != nil {
+	if err := c.mount(namespace.RootContext(nil), me); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Store the view
-	view := c.router.MatchingStorageByAPIPath(namespace.TestContext(), "test/")
+	view := c.router.MatchingStorageByAPIPath(namespace.RootContext(nil), "test/")
 
 	// Inject data
 	se := &logical.StorageEntry{
@@ -417,7 +417,7 @@ func TestCore_Remount_Cleanup(t *testing.T) {
 		ClientToken: root,
 	}
 	r.SetTokenEntry(&logical.TokenEntry{ID: root, NamespaceID: "root", Policies: []string{"root"}})
-	resp, err := c.HandleRequest(namespace.TestContext(), r)
+	resp, err := c.HandleRequest(namespace.RootContext(nil), r)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -426,7 +426,7 @@ func TestCore_Remount_Cleanup(t *testing.T) {
 	}
 
 	// Remount, this should cleanup
-	if err := c.remount(namespace.TestContext(), "test/", "new/"); err != nil {
+	if err := c.remount(namespace.RootContext(nil), "test/", "new/"); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -455,7 +455,7 @@ func TestCore_Remount_Cleanup(t *testing.T) {
 
 func TestCore_Remount_Protected(t *testing.T) {
 	c, _, _ := TestCoreUnsealed(t)
-	err := c.remount(namespace.TestContext(), "sys", "foo")
+	err := c.remount(namespace.RootContext(nil), "sys", "foo")
 	if err.Error() != `cannot remount "sys/"` {
 		t.Fatalf("err: %v", err)
 	}
@@ -481,7 +481,7 @@ func TestCore_MountTable_UpgradeToTyped(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err := c.enableAudit(namespace.TestContext(), me, true)
+	err := c.enableAudit(namespace.RootContext(nil), me, true)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -495,7 +495,7 @@ func TestCore_MountTable_UpgradeToTyped(t *testing.T) {
 		Path:  "foo",
 		Type:  "noop",
 	}
-	err = c.enableCredential(namespace.TestContext(), me)
+	err = c.enableCredential(namespace.RootContext(nil), me)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
diff --git a/vault/rollback_test.go b/vault/rollback_test.go
index a5d106fed9..e6769672eb 100644
--- a/vault/rollback_test.go
+++ b/vault/rollback_test.go
@@ -27,7 +27,7 @@ func mockRollback(t *testing.T) (*RollbackManager, *NoopBackend) {
 		&MountEntry{
 			Path:        "foo",
 			NamespaceID: namespace.RootNamespaceID,
-			namespace:   namespace.TestNamespace(),
+			namespace:   namespace.RootNamespace,
 		},
 	}
 	meUUID, err := uuid.GenerateUUID()
@@ -35,7 +35,7 @@ func mockRollback(t *testing.T) (*RollbackManager, *NoopBackend) {
 		t.Fatal(err)
 	}
 
-	if err := router.Mount(backend, "foo", &MountEntry{UUID: meUUID, Accessor: "noopaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}, view); err != nil {
+	if err := router.Mount(backend, "foo", &MountEntry{UUID: meUUID, Accessor: "noopaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}, view); err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
@@ -90,7 +90,7 @@ func TestRollbackManager_Join(t *testing.T) {
 	errCh := make(chan error, 3)
 	go func() {
 		defer wg.Done()
-		err := m.Rollback(namespace.TestContext(), "foo")
+		err := m.Rollback(namespace.RootContext(nil), "foo")
 		if err != nil {
 			errCh <- err
 		}
@@ -98,7 +98,7 @@ func TestRollbackManager_Join(t *testing.T) {
 
 	go func() {
 		defer wg.Done()
-		err := m.Rollback(namespace.TestContext(), "foo")
+		err := m.Rollback(namespace.RootContext(nil), "foo")
 		if err != nil {
 			errCh <- err
 		}
@@ -106,7 +106,7 @@ func TestRollbackManager_Join(t *testing.T) {
 
 	go func() {
 		defer wg.Done()
-		err := m.Rollback(namespace.TestContext(), "foo")
+		err := m.Rollback(namespace.RootContext(nil), "foo")
 		if err != nil {
 			errCh <- err
 		}
diff --git a/vault/router_test.go b/vault/router_test.go
index e72455220d..c08e631a02 100644
--- a/vault/router_test.go
+++ b/vault/router_test.go
@@ -122,7 +122,7 @@ func TestRouter_Mount(t *testing.T) {
 		UUID:        meUUID,
 		Accessor:    "awsaccessor",
 		NamespaceID: namespace.RootNamespaceID,
-		namespace:   namespace.TestNamespace(),
+		namespace:   namespace.RootNamespace,
 	}
 
 	n := &NoopBackend{}
@@ -136,7 +136,7 @@ func TestRouter_Mount(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = r.Mount(n, "prod/aws/", &MountEntry{UUID: meUUID, NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}, view)
+	err = r.Mount(n, "prod/aws/", &MountEntry{UUID: meUUID, NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}, view)
 	if !strings.Contains(err.Error(), "cannot mount under existing mount") {
 		t.Fatalf("err: %v", err)
 	}
@@ -146,19 +146,19 @@ func TestRouter_Mount(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if path := r.MatchingMount(namespace.TestContext(), "prod/aws/foo"); path != "prod/aws/" {
+	if path := r.MatchingMount(namespace.RootContext(nil), "prod/aws/foo"); path != "prod/aws/" {
 		t.Fatalf("bad: %s", path)
 	}
 
-	if v := r.MatchingStorageByAPIPath(namespace.TestContext(), "prod/aws/foo"); v.(*BarrierView) != view {
+	if v := r.MatchingStorageByAPIPath(namespace.RootContext(nil), "prod/aws/foo"); v.(*BarrierView) != view {
 		t.Fatalf("bad: %v", v)
 	}
 
-	if path := r.MatchingMount(namespace.TestContext(), "stage/aws/foo"); path != "" {
+	if path := r.MatchingMount(namespace.RootContext(nil), "stage/aws/foo"); path != "" {
 		t.Fatalf("bad: %s", path)
 	}
 
-	if v := r.MatchingStorageByAPIPath(namespace.TestContext(), "stage/aws/foo"); v != nil {
+	if v := r.MatchingStorageByAPIPath(namespace.RootContext(nil), "stage/aws/foo"); v != nil {
 		t.Fatalf("bad: %v", v)
 	}
 
@@ -167,7 +167,7 @@ func TestRouter_Mount(t *testing.T) {
 		t.Fatalf("failed to fetch mount entry using its ID; expected: %#v\n actual: %#v\n", mountEntry, mountEntryFetched)
 	}
 
-	_, mount, prefix, ok := r.MatchingAPIPrefixByStoragePath(namespace.TestContext(), "logical/foo")
+	_, mount, prefix, ok := r.MatchingAPIPrefixByStoragePath(namespace.RootContext(nil), "logical/foo")
 	if !ok {
 		t.Fatalf("missing storage prefix")
 	}
@@ -181,7 +181,7 @@ func TestRouter_Mount(t *testing.T) {
 	req.SetTokenEntry(&logical.TokenEntry{
 		ID: "foo",
 	})
-	resp, err := r.Route(namespace.TestContext(), req)
+	resp, err := r.Route(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -202,10 +202,10 @@ func TestRouter_Mount(t *testing.T) {
 		UUID:        meUUID,
 		Accessor:    "prodaccessor",
 		NamespaceID: namespace.RootNamespaceID,
-		namespace:   namespace.TestNamespace(),
+		namespace:   namespace.RootNamespace,
 	}
 
-	if r.MountConflict(namespace.TestContext(), "prod/aws/") == "" {
+	if r.MountConflict(namespace.RootContext(nil), "prod/aws/") == "" {
 		t.Fatalf("bad: prod/aws/")
 	}
 
@@ -214,7 +214,7 @@ func TestRouter_Mount(t *testing.T) {
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
-	if r.MountConflict(namespace.TestContext(), "prod/test") == "" {
+	if r.MountConflict(namespace.RootContext(nil), "prod/test") == "" {
 		t.Fatalf("bad: prod/test/")
 	}
 }
@@ -234,7 +234,7 @@ func TestRouter_MountCredential(t *testing.T) {
 		UUID:        meUUID,
 		Accessor:    "awsaccessor",
 		NamespaceID: namespace.RootNamespaceID,
-		namespace:   namespace.TestNamespace(),
+		namespace:   namespace.RootNamespace,
 	}
 
 	n := &NoopBackend{}
@@ -248,24 +248,24 @@ func TestRouter_MountCredential(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	err = r.Mount(n, "auth/aws/", &MountEntry{UUID: meUUID, NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}, view)
+	err = r.Mount(n, "auth/aws/", &MountEntry{UUID: meUUID, NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}, view)
 	if !strings.Contains(err.Error(), "cannot mount under existing mount") {
 		t.Fatalf("err: %v", err)
 	}
 
-	if path := r.MatchingMount(namespace.TestContext(), "auth/aws/foo"); path != "auth/aws/" {
+	if path := r.MatchingMount(namespace.RootContext(nil), "auth/aws/foo"); path != "auth/aws/" {
 		t.Fatalf("bad: %s", path)
 	}
 
-	if v := r.MatchingStorageByAPIPath(namespace.TestContext(), "auth/aws/foo"); v.(*BarrierView) != view {
+	if v := r.MatchingStorageByAPIPath(namespace.RootContext(nil), "auth/aws/foo"); v.(*BarrierView) != view {
 		t.Fatalf("bad: %v", v)
 	}
 
-	if path := r.MatchingMount(namespace.TestContext(), "auth/stage/aws/foo"); path != "" {
+	if path := r.MatchingMount(namespace.RootContext(nil), "auth/stage/aws/foo"); path != "" {
 		t.Fatalf("bad: %s", path)
 	}
 
-	if v := r.MatchingStorageByAPIPath(namespace.TestContext(), "auth/stage/aws/foo"); v != nil {
+	if v := r.MatchingStorageByAPIPath(namespace.RootContext(nil), "auth/stage/aws/foo"); v != nil {
 		t.Fatalf("bad: %v", v)
 	}
 
@@ -274,7 +274,7 @@ func TestRouter_MountCredential(t *testing.T) {
 		t.Fatalf("failed to fetch mount entry using its ID; expected: %#v\n actual: %#v\n", mountEntry, mountEntryFetched)
 	}
 
-	_, mount, prefix, ok := r.MatchingAPIPrefixByStoragePath(namespace.TestContext(), "auth/foo")
+	_, mount, prefix, ok := r.MatchingAPIPrefixByStoragePath(namespace.RootContext(nil), "auth/foo")
 	if !ok {
 		t.Fatalf("missing storage prefix")
 	}
@@ -285,7 +285,7 @@ func TestRouter_MountCredential(t *testing.T) {
 	req := &logical.Request{
 		Path: "auth/aws/foo",
 	}
-	resp, err := r.Route(namespace.TestContext(), req)
+	resp, err := r.Route(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -309,12 +309,12 @@ func TestRouter_Unmount(t *testing.T) {
 		t.Fatal(err)
 	}
 	n := &NoopBackend{}
-	err = r.Mount(n, "prod/aws/", &MountEntry{Path: "prod/aws/", UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}, view)
+	err = r.Mount(n, "prod/aws/", &MountEntry{Path: "prod/aws/", UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	err = r.Unmount(namespace.TestContext(), "prod/aws/")
+	err = r.Unmount(namespace.RootContext(nil), "prod/aws/")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -322,12 +322,12 @@ func TestRouter_Unmount(t *testing.T) {
 	req := &logical.Request{
 		Path: "prod/aws/foo",
 	}
-	_, err = r.Route(namespace.TestContext(), req)
+	_, err = r.Route(namespace.RootContext(nil), req)
 	if !strings.Contains(err.Error(), "unsupported path") {
 		t.Fatalf("err: %v", err)
 	}
 
-	if _, _, _, ok := r.MatchingAPIPrefixByStoragePath(namespace.TestContext(), "logical/foo"); ok {
+	if _, _, _, ok := r.MatchingAPIPrefixByStoragePath(namespace.RootContext(nil), "logical/foo"); ok {
 		t.Fatalf("should not have matching storage prefix")
 	}
 }
@@ -342,19 +342,19 @@ func TestRouter_Remount(t *testing.T) {
 		t.Fatal(err)
 	}
 	n := &NoopBackend{}
-	me := &MountEntry{Path: "prod/aws/", UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}
+	me := &MountEntry{Path: "prod/aws/", UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}
 	err = r.Mount(n, "prod/aws/", me, view)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	me.Path = "stage/aws/"
-	err = r.Remount(namespace.TestContext(), "prod/aws/", "stage/aws/")
+	err = r.Remount(namespace.RootContext(nil), "prod/aws/", "stage/aws/")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	err = r.Remount(namespace.TestContext(), "prod/aws/", "stage/aws/")
+	err = r.Remount(namespace.RootContext(nil), "prod/aws/", "stage/aws/")
 	if !strings.Contains(err.Error(), "no mount at") {
 		t.Fatalf("err: %v", err)
 	}
@@ -362,7 +362,7 @@ func TestRouter_Remount(t *testing.T) {
 	req := &logical.Request{
 		Path: "prod/aws/foo",
 	}
-	_, err = r.Route(namespace.TestContext(), req)
+	_, err = r.Route(namespace.RootContext(nil), req)
 	if !strings.Contains(err.Error(), "unsupported path") {
 		t.Fatalf("err: %v", err)
 	}
@@ -370,7 +370,7 @@ func TestRouter_Remount(t *testing.T) {
 	req = &logical.Request{
 		Path: "stage/aws/foo",
 	}
-	_, err = r.Route(namespace.TestContext(), req)
+	_, err = r.Route(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -381,7 +381,7 @@ func TestRouter_Remount(t *testing.T) {
 	}
 
 	// Check the resolve from storage still works
-	_, mount, prefix, _ := r.MatchingAPIPrefixByStoragePath(namespace.TestContext(), "logical/foobar")
+	_, mount, prefix, _ := r.MatchingAPIPrefixByStoragePath(namespace.RootContext(nil), "logical/foobar")
 	if mount != "stage/aws/" {
 		t.Fatalf("bad mount: %s", mount)
 	}
@@ -405,7 +405,7 @@ func TestRouter_RootPath(t *testing.T) {
 			"policy/*",
 		},
 	}
-	err = r.Mount(n, "prod/aws/", &MountEntry{UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}, view)
+	err = r.Mount(n, "prod/aws/", &MountEntry{UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -425,7 +425,7 @@ func TestRouter_RootPath(t *testing.T) {
 	}
 
 	for _, tc := range tcases {
-		out := r.RootPath(namespace.TestContext(), tc.path)
+		out := r.RootPath(namespace.RootContext(nil), tc.path)
 		if out != tc.expect {
 			t.Fatalf("bad: path: %s expect: %v got %v", tc.path, tc.expect, out)
 		}
@@ -447,7 +447,7 @@ func TestRouter_LoginPath(t *testing.T) {
 			"oauth/*",
 		},
 	}
-	err = r.Mount(n, "auth/foo/", &MountEntry{UUID: meUUID, Accessor: "authfooaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}, view)
+	err = r.Mount(n, "auth/foo/", &MountEntry{UUID: meUUID, Accessor: "authfooaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -465,7 +465,7 @@ func TestRouter_LoginPath(t *testing.T) {
 	}
 
 	for _, tc := range tcases {
-		out := r.LoginPath(namespace.TestContext(), tc.path)
+		out := r.LoginPath(namespace.RootContext(nil), tc.path)
 		if out != tc.expect {
 			t.Fatalf("bad: path: %s expect: %v got %v", tc.path, tc.expect, out)
 		}
@@ -482,12 +482,12 @@ func TestRouter_Taint(t *testing.T) {
 		t.Fatal(err)
 	}
 	n := &NoopBackend{}
-	err = r.Mount(n, "prod/aws/", &MountEntry{UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}, view)
+	err = r.Mount(n, "prod/aws/", &MountEntry{UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	err = r.Taint(namespace.TestContext(), "prod/aws/")
+	err = r.Taint(namespace.RootContext(nil), "prod/aws/")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -496,20 +496,20 @@ func TestRouter_Taint(t *testing.T) {
 		Operation: logical.ReadOperation,
 		Path:      "prod/aws/foo",
 	}
-	_, err = r.Route(namespace.TestContext(), req)
+	_, err = r.Route(namespace.RootContext(nil), req)
 	if err.Error() != "unsupported path" {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Rollback and Revoke should work
 	req.Operation = logical.RollbackOperation
-	_, err = r.Route(namespace.TestContext(), req)
+	_, err = r.Route(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	req.Operation = logical.RevokeOperation
-	_, err = r.Route(namespace.TestContext(), req)
+	_, err = r.Route(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -525,17 +525,17 @@ func TestRouter_Untaint(t *testing.T) {
 		t.Fatal(err)
 	}
 	n := &NoopBackend{}
-	err = r.Mount(n, "prod/aws/", &MountEntry{UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.TestNamespace()}, view)
+	err = r.Mount(n, "prod/aws/", &MountEntry{UUID: meUUID, Accessor: "awsaccessor", NamespaceID: namespace.RootNamespaceID, namespace: namespace.RootNamespace}, view)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	err = r.Taint(namespace.TestContext(), "prod/aws/")
+	err = r.Taint(namespace.RootContext(nil), "prod/aws/")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	err = r.Untaint(namespace.TestContext(), "prod/aws/")
+	err = r.Untaint(namespace.RootContext(nil), "prod/aws/")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -544,7 +544,7 @@ func TestRouter_Untaint(t *testing.T) {
 		Operation: logical.ReadOperation,
 		Path:      "prod/aws/foo",
 	}
-	_, err = r.Route(namespace.TestContext(), req)
+	_, err = r.Route(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
diff --git a/vault/token_store_test.go b/vault/token_store_test.go
index f08227e699..46ddbd0ca6 100644
--- a/vault/token_store_test.go
+++ b/vault/token_store_test.go
@@ -152,7 +152,7 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	saltedID, err := ts.SaltID(namespace.TestContext(), entry.ID)
+	saltedID, err := ts.SaltID(namespace.RootContext(nil), entry.ID)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -161,7 +161,7 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		Value: enc,
 	}
 
-	if err := ts.idView(namespace.RootNamespace).Put(namespace.TestContext(), le); err != nil {
+	if err := ts.idView(namespace.RootNamespace).Put(namespace.RootContext(nil), le); err != nil {
 		t.Fatal(err)
 	}
 
@@ -188,11 +188,11 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		NamespaceID:    namespace.RootNamespaceID,
 	}
 
-	if err := ts.expiration.RegisterAuth(namespace.TestContext(), registryEntry, auth); err != nil {
+	if err := ts.expiration.RegisterAuth(namespace.RootContext(nil), registryEntry, auth); err != nil {
 		t.Fatal(err)
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), entry.ID)
+	out, err := ts.Lookup(namespace.RootContext(nil), entry.ID)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -219,7 +219,7 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		NumUses:        10,
 		NamespaceID:    namespace.RootNamespaceID,
 	}
-	if err := ts.create(namespace.TestContext(), ent); err != nil {
+	if err := ts.create(namespace.RootContext(nil), ent); err != nil {
 		t.Fatalf("err: %s", err)
 	}
 	auth = &logical.Auth{
@@ -233,11 +233,11 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		},
 		ClientToken: ent.ID,
 	}
-	if err := ts.expiration.RegisterAuth(namespace.TestContext(), ent, auth); err != nil {
+	if err := ts.expiration.RegisterAuth(namespace.RootContext(nil), ent, auth); err != nil {
 		t.Fatal(err)
 	}
 
-	out, err = ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err = ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -264,7 +264,7 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		NumUsesDeprecated:        10,
 		NamespaceID:              namespace.RootNamespaceID,
 	}
-	if err := ts.create(namespace.TestContext(), ent); err != nil {
+	if err := ts.create(namespace.RootContext(nil), ent); err != nil {
 		t.Fatalf("err: %s", err)
 	}
 	auth = &logical.Auth{
@@ -278,11 +278,11 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		},
 		ClientToken: ent.ID,
 	}
-	if err := ts.expiration.RegisterAuth(namespace.TestContext(), ent, auth); err != nil {
+	if err := ts.expiration.RegisterAuth(namespace.RootContext(nil), ent, auth); err != nil {
 		t.Fatal(err)
 	}
 
-	out, err = ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err = ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -306,7 +306,7 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		NumUsesDeprecated: 10,
 		NamespaceID:       namespace.RootNamespaceID,
 	}
-	if err := ts.create(namespace.TestContext(), ent); err != nil {
+	if err := ts.create(namespace.RootContext(nil), ent); err != nil {
 		t.Fatalf("err: %s", err)
 	}
 	auth = &logical.Auth{
@@ -320,11 +320,11 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		},
 		ClientToken: ent.ID,
 	}
-	if err := ts.expiration.RegisterAuth(namespace.TestContext(), ent, auth); err != nil {
+	if err := ts.expiration.RegisterAuth(namespace.RootContext(nil), ent, auth); err != nil {
 		t.Fatal(err)
 	}
 
-	out, err = ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err = ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -340,7 +340,7 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		NumUsesDeprecated: 5,
 		NamespaceID:       namespace.RootNamespaceID,
 	}
-	if err := ts.create(namespace.TestContext(), ent); err != nil {
+	if err := ts.create(namespace.RootContext(nil), ent); err != nil {
 		t.Fatalf("err: %s", err)
 	}
 	auth = &logical.Auth{
@@ -354,11 +354,11 @@ func TestTokenStore_TokenEntryUpgrade(t *testing.T) {
 		},
 		ClientToken: ent.ID,
 	}
-	if err := ts.expiration.RegisterAuth(namespace.TestContext(), ent, auth); err != nil {
+	if err := ts.expiration.RegisterAuth(namespace.RootContext(nil), ent, auth); err != nil {
 		t.Fatal(err)
 	}
 
-	out, err = ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err = ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -403,7 +403,7 @@ func testMakeTokenViaBackend(t testing.TB, ts *TokenStore, root, client, ttl str
 }
 
 func testMakeTokenViaRequest(t testing.TB, ts *TokenStore, req *logical.Request) *logical.Response {
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -421,12 +421,12 @@ func testMakeTokenViaRequest(t testing.TB, ts *TokenStore, req *logical.Request)
 	}
 
 	if resp.Auth.TokenType != logical.TokenTypeBatch {
-		if err := ts.expiration.RegisterAuth(namespace.TestContext(), te, resp.Auth); err != nil {
+		if err := ts.expiration.RegisterAuth(namespace.RootContext(nil), te, resp.Auth); err != nil {
 			t.Fatal(err)
 		}
 	}
 
-	te, err = ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	te, err = ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -467,7 +467,7 @@ func testMakeTokenDirectly(t testing.TB, ts *TokenStore, te *logical.TokenEntry)
 		CreationPath:   te.Path,
 		TokenType:      te.Type,
 	}
-	err := ts.expiration.RegisterAuth(namespace.TestContext(), te, auth)
+	err := ts.expiration.RegisterAuth(namespace.RootContext(nil), te, auth)
 	switch err {
 	case nil:
 		if te.Type == logical.TokenTypeBatch {
@@ -499,7 +499,7 @@ func testMakeTokenViaCore(t testing.TB, c *Core, root, client, ttl string, polic
 	req.Data["policies"] = policy
 	req.Data["ttl"] = ttl
 
-	resp, err := c.HandleRequest(namespace.TestContext(), req)
+	resp, err := c.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -525,7 +525,7 @@ func TestTokenStore_AccessorIndex(t *testing.T) {
 	}
 	testMakeTokenDirectly(t, ts, ent)
 
-	out, err := ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err := ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -535,7 +535,7 @@ func TestTokenStore_AccessorIndex(t *testing.T) {
 		t.Fatalf("bad: %#v", out)
 	}
 
-	aEntry, err := ts.lookupByAccessor(namespace.TestContext(), out.Accessor, false, false)
+	aEntry, err := ts.lookupByAccessor(namespace.RootContext(nil), out.Accessor, false, false)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -549,7 +549,7 @@ func TestTokenStore_AccessorIndex(t *testing.T) {
 	ent.Type = logical.TokenTypeBatch
 	testMakeTokenDirectly(t, ts, ent)
 
-	out, err = ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err = ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -565,7 +565,7 @@ func TestTokenStore_HandleRequest_LookupAccessor(t *testing.T) {
 	ts := c.tokenStore
 
 	testMakeServiceTokenViaBackend(t, ts, root, "tokenid", "", []string{"foo"})
-	out, err := ts.Lookup(namespace.TestContext(), "tokenid")
+	out, err := ts.Lookup(namespace.RootContext(nil), "tokenid")
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -578,7 +578,7 @@ func TestTokenStore_HandleRequest_LookupAccessor(t *testing.T) {
 		"accessor": out.Accessor,
 	}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -606,15 +606,15 @@ func TestTokenStore_HandleRequest_ListAccessors(t *testing.T) {
 	}
 
 	// Revoke root to make the number of accessors match
-	salted, err := ts.SaltID(namespace.TestContext(), root)
+	salted, err := ts.SaltID(namespace.RootContext(nil), root)
 	if err != nil {
 		t.Fatal(err)
 	}
-	ts.revokeInternal(namespace.TestContext(), salted, false)
+	ts.revokeInternal(namespace.RootContext(nil), salted, false)
 
 	req := logical.TestRequest(t, logical.ListOperation, "accessors/")
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -634,25 +634,25 @@ func TestTokenStore_HandleRequest_ListAccessors(t *testing.T) {
 
 	// Test upgrade from old struct method of accessor storage (of token id)
 	for _, accessor := range keys {
-		aEntry, err := ts.lookupByAccessor(namespace.TestContext(), accessor, false, false)
+		aEntry, err := ts.lookupByAccessor(namespace.RootContext(nil), accessor, false, false)
 		if err != nil {
 			t.Fatal(err)
 		}
 		if aEntry.TokenID == "" || aEntry.AccessorID == "" {
 			t.Fatalf("error, accessor entry looked up is empty, but no error thrown")
 		}
-		saltID, err := ts.SaltID(namespace.TestContext(), accessor)
+		saltID, err := ts.SaltID(namespace.RootContext(nil), accessor)
 		if err != nil {
 			t.Fatal(err)
 		}
 		le := &logical.StorageEntry{Key: saltID, Value: []byte(aEntry.TokenID)}
-		if err := ts.accessorView(namespace.RootNamespace).Put(namespace.TestContext(), le); err != nil {
+		if err := ts.accessorView(namespace.RootNamespace).Put(namespace.RootContext(nil), le); err != nil {
 			t.Fatalf("failed to persist accessor index entry: %v", err)
 		}
 	}
 
 	// Do the lookup again, should get same result
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -671,7 +671,7 @@ func TestTokenStore_HandleRequest_ListAccessors(t *testing.T) {
 	}
 
 	for _, accessor := range keys2 {
-		aEntry, err := ts.lookupByAccessor(namespace.TestContext(), accessor, false, false)
+		aEntry, err := ts.lookupByAccessor(namespace.RootContext(nil), accessor, false, false)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -685,7 +685,7 @@ func TestTokenStore_HandleRequest_RevokeAccessor(t *testing.T) {
 	exp := mockExpiration(t)
 	ts := exp.tokenStore
 
-	rootToken, err := ts.rootToken(namespace.TestContext())
+	rootToken, err := ts.rootToken(namespace.RootContext(nil))
 	root := rootToken.ID
 
 	testMakeServiceTokenViaBackend(t, ts, root, "tokenid", "", []string{"foo"})
@@ -698,7 +698,7 @@ func TestTokenStore_HandleRequest_RevokeAccessor(t *testing.T) {
 		},
 	}
 
-	te, err := ts.Lookup(namespace.TestContext(), "tokenid")
+	te, err := ts.Lookup(namespace.RootContext(nil), "tokenid")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -706,12 +706,12 @@ func TestTokenStore_HandleRequest_RevokeAccessor(t *testing.T) {
 		t.Fatal("token entry was nil")
 	}
 
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), "tokenid")
+	out, err := ts.Lookup(namespace.RootContext(nil), "tokenid")
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -724,14 +724,14 @@ func TestTokenStore_HandleRequest_RevokeAccessor(t *testing.T) {
 		"accessor": out.Accessor,
 	}
 
-	_, err = ts.HandleRequest(namespace.TestContext(), req)
+	_, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
 	time.Sleep(200 * time.Millisecond)
 
-	out, err = ts.Lookup(namespace.TestContext(), "tokenid")
+	out, err = ts.Lookup(namespace.RootContext(nil), "tokenid")
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -742,7 +742,7 @@ func TestTokenStore_HandleRequest_RevokeAccessor(t *testing.T) {
 
 	// Now test without registering the token through the expiration manager
 	testMakeServiceTokenViaBackend(t, ts, root, "tokenid", "", []string{"foo"})
-	out, err = ts.Lookup(namespace.TestContext(), "tokenid")
+	out, err = ts.Lookup(namespace.RootContext(nil), "tokenid")
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -755,14 +755,14 @@ func TestTokenStore_HandleRequest_RevokeAccessor(t *testing.T) {
 		"accessor": out.Accessor,
 	}
 
-	_, err = ts.HandleRequest(namespace.TestContext(), req)
+	_, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
 
 	time.Sleep(200 * time.Millisecond)
 
-	out, err = ts.Lookup(namespace.TestContext(), "tokenid")
+	out, err = ts.Lookup(namespace.RootContext(nil), "tokenid")
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
@@ -776,7 +776,7 @@ func TestTokenStore_RootToken(t *testing.T) {
 	c, _, _ := TestCoreUnsealed(t)
 	ts := c.tokenStore
 
-	te, err := ts.rootToken(namespace.TestContext())
+	te, err := ts.rootToken(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -784,7 +784,7 @@ func TestTokenStore_RootToken(t *testing.T) {
 		t.Fatalf("missing ID")
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), te.ID)
+	out, err := ts.Lookup(namespace.RootContext(nil), te.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -802,7 +802,7 @@ func TestTokenStore_NoRootBatch(t *testing.T) {
 	req.Data["policies"] = "root"
 	req.Data["ttl"] = "5m"
 
-	resp, err := c.HandleRequest(namespace.TestContext(), req)
+	resp, err := c.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -829,7 +829,7 @@ func TestTokenStore_CreateLookup(t *testing.T) {
 		t.Fatalf("missing ID")
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err := ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -838,14 +838,14 @@ func TestTokenStore_CreateLookup(t *testing.T) {
 	}
 
 	// New store should share the salt
-	ts2, err := NewTokenStore(namespace.TestContext(), hclog.New(&hclog.LoggerOptions{}), c, getBackendConfig(c))
+	ts2, err := NewTokenStore(namespace.RootContext(nil), hclog.New(&hclog.LoggerOptions{}), c, getBackendConfig(c))
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 	ts2.SetExpirationManager(c.expiration)
 
 	// Should still match
-	out, err = ts2.Lookup(namespace.TestContext(), ent.ID)
+	out, err = ts2.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -869,11 +869,11 @@ func TestTokenStore_CreateLookup_ProvidedID(t *testing.T) {
 	if ent.ID != "foobarbaz" {
 		t.Fatalf("bad: ent.ID: expected:\"foobarbaz\"\n actual:%s", ent.ID)
 	}
-	if err := ts.create(namespace.TestContext(), ent); err == nil {
+	if err := ts.create(namespace.RootContext(nil), ent); err == nil {
 		t.Fatal("expected error creating token with the same ID")
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err := ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -882,14 +882,14 @@ func TestTokenStore_CreateLookup_ProvidedID(t *testing.T) {
 	}
 
 	// New store should share the salt
-	ts2, err := NewTokenStore(namespace.TestContext(), hclog.New(&hclog.LoggerOptions{}), c, getBackendConfig(c))
+	ts2, err := NewTokenStore(namespace.RootContext(nil), hclog.New(&hclog.LoggerOptions{}), c, getBackendConfig(c))
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 	ts2.SetExpirationManager(c.expiration)
 
 	// Should still match
-	out, err = ts2.Lookup(namespace.TestContext(), ent.ID)
+	out, err = ts2.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -907,7 +907,7 @@ func TestTokenStore_CreateLookup_ExpirationInRestoreMode(t *testing.T) {
 		Path:        "test",
 		Policies:    []string{"dev", "ops"},
 	}
-	if err := ts.create(namespace.TestContext(), ent); err != nil {
+	if err := ts.create(namespace.RootContext(nil), ent); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 	if ent.ID == "" {
@@ -915,7 +915,7 @@ func TestTokenStore_CreateLookup_ExpirationInRestoreMode(t *testing.T) {
 	}
 
 	// Replace the lease with a lease with an expire time in the past
-	saltedID, err := ts.SaltID(namespace.TestContext(), ent.ID)
+	saltedID, err := ts.SaltID(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -930,11 +930,11 @@ func TestTokenStore_CreateLookup_ExpirationInRestoreMode(t *testing.T) {
 		ExpireTime:  time.Now().Add(1 * time.Hour),
 		namespace:   namespace.RootNamespace,
 	}
-	if err := ts.expiration.persistEntry(namespace.TestContext(), le); err != nil {
+	if err := ts.expiration.persistEntry(namespace.RootContext(nil), le); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err := ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -944,7 +944,7 @@ func TestTokenStore_CreateLookup_ExpirationInRestoreMode(t *testing.T) {
 
 	// Set to expired lease time
 	le.ExpireTime = time.Now().Add(-1 * time.Hour)
-	if err := ts.expiration.persistEntry(namespace.TestContext(), le); err != nil {
+	if err := ts.expiration.persistEntry(namespace.RootContext(nil), le); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -961,7 +961,7 @@ func TestTokenStore_CreateLookup_ExpirationInRestoreMode(t *testing.T) {
 
 	// Test that the token lookup does not return the token entry due to the
 	// expired lease
-	out, err = ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err = ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -975,13 +975,13 @@ func TestTokenStore_UseToken(t *testing.T) {
 	ts := c.tokenStore
 
 	// Lookup the root token
-	ent, err := ts.Lookup(namespace.TestContext(), root)
+	ent, err := ts.Lookup(namespace.RootContext(nil), root)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Root is an unlimited use token, should be a no-op
-	te, err := ts.UseToken(namespace.TestContext(), ent)
+	te, err := ts.UseToken(namespace.RootContext(nil), ent)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -990,7 +990,7 @@ func TestTokenStore_UseToken(t *testing.T) {
 	}
 
 	// Lookup the root token again
-	ent2, err := ts.Lookup(namespace.TestContext(), root)
+	ent2, err := ts.Lookup(namespace.RootContext(nil), root)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1010,7 +1010,7 @@ func TestTokenStore_UseToken(t *testing.T) {
 	testMakeTokenDirectly(t, ts, ent)
 
 	// Use the token
-	te, err = ts.UseToken(namespace.TestContext(), ent)
+	te, err = ts.UseToken(namespace.RootContext(nil), ent)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1019,7 +1019,7 @@ func TestTokenStore_UseToken(t *testing.T) {
 	}
 
 	// Lookup the token
-	ent2, err = ts.Lookup(namespace.TestContext(), ent.ID)
+	ent2, err = ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1030,7 +1030,7 @@ func TestTokenStore_UseToken(t *testing.T) {
 	}
 
 	// Use the token
-	te, err = ts.UseToken(namespace.TestContext(), ent)
+	te, err = ts.UseToken(namespace.RootContext(nil), ent)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1040,10 +1040,10 @@ func TestTokenStore_UseToken(t *testing.T) {
 	if te.NumUses != tokenRevocationPending {
 		t.Fatalf("token entry after use #2 did not have revoke flag")
 	}
-	ts.revokeOrphan(namespace.TestContext(), te.ID)
+	ts.revokeOrphan(namespace.RootContext(nil), te.ID)
 
 	// Lookup the token
-	ent2, err = ts.Lookup(namespace.TestContext(), ent.ID)
+	ent2, err = ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1059,20 +1059,20 @@ func TestTokenStore_Revoke(t *testing.T) {
 	ts := c.tokenStore
 
 	ent := &logical.TokenEntry{Path: "test", Policies: []string{"dev", "ops"}, NamespaceID: namespace.RootNamespaceID}
-	if err := ts.create(namespace.TestContext(), ent); err != nil {
+	if err := ts.create(namespace.RootContext(nil), ent); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	err := ts.revokeOrphan(namespace.TestContext(), "")
+	err := ts.revokeOrphan(namespace.RootContext(nil), "")
 	if err.Error() != "cannot revoke blank token" {
 		t.Fatalf("err: %v", err)
 	}
-	err = ts.revokeOrphan(namespace.TestContext(), ent.ID)
+	err = ts.revokeOrphan(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), ent.ID)
+	out, err := ts.Lookup(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1095,7 +1095,7 @@ func TestTokenStore_Revoke_Leases(t *testing.T) {
 	}
 
 	ent := &logical.TokenEntry{Path: "test", Policies: []string{"dev", "ops"}, NamespaceID: namespace.RootNamespaceID}
-	if err := ts.create(namespace.TestContext(), ent); err != nil {
+	if err := ts.create(namespace.RootContext(nil), ent); err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
@@ -1117,13 +1117,13 @@ func TestTokenStore_Revoke_Leases(t *testing.T) {
 			"secret_key": "abcd",
 		},
 	}
-	leaseID, err := ts.expiration.Register(namespace.TestContext(), req, resp)
+	leaseID, err := ts.expiration.Register(namespace.RootContext(nil), req, resp)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Revoke the token
-	err = ts.revokeOrphan(namespace.TestContext(), ent.ID)
+	err = ts.revokeOrphan(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1131,7 +1131,7 @@ func TestTokenStore_Revoke_Leases(t *testing.T) {
 	time.Sleep(200 * time.Millisecond)
 
 	// Verify the lease is gone
-	out, err := ts.expiration.loadEntry(namespace.TestContext(), leaseID)
+	out, err := ts.expiration.loadEntry(namespace.RootContext(nil), leaseID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1159,12 +1159,12 @@ func TestTokenStore_Revoke_Orphan(t *testing.T) {
 	}
 	testMakeTokenDirectly(t, ts, ent2)
 
-	err := ts.revokeOrphan(namespace.TestContext(), ent.ID)
+	err := ts.revokeOrphan(namespace.RootContext(nil), ent.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), ent2.ID)
+	out, err := ts.Lookup(namespace.RootContext(nil), ent2.ID)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1199,46 +1199,46 @@ func testTokenStore_RevokeTree_NonRecursive(t testing.TB, depth uint64, injectCy
 	var cyclePaths []string
 	if injectCycles {
 		// Make the root the parent of itself
-		saltedRoot, _ := ts.SaltID(namespace.TestContext(), root.ID)
+		saltedRoot, _ := ts.SaltID(namespace.RootContext(nil), root.ID)
 		key := fmt.Sprintf("%s/%s", saltedRoot, saltedRoot)
 		cyclePaths = append(cyclePaths, key)
 		le := &logical.StorageEntry{Key: key}
 
-		if err := ts.parentView(namespace.TestNamespace()).Put(namespace.TestContext(), le); err != nil {
+		if err := ts.parentView(namespace.RootNamespace).Put(namespace.RootContext(nil), le); err != nil {
 			t.Fatalf("err: %v", err)
 		}
 
 		// Make a deep child the parent of a shallow child
-		shallow, _ := ts.SaltID(namespace.TestContext(), children[0].ID)
-		deep, _ := ts.SaltID(namespace.TestContext(), children[len(children)-1].ID)
+		shallow, _ := ts.SaltID(namespace.RootContext(nil), children[0].ID)
+		deep, _ := ts.SaltID(namespace.RootContext(nil), children[len(children)-1].ID)
 		key = fmt.Sprintf("%s/%s", deep, shallow)
 		cyclePaths = append(cyclePaths, key)
 		le = &logical.StorageEntry{Key: key}
 
-		if err := ts.parentView(namespace.TestNamespace()).Put(namespace.TestContext(), le); err != nil {
+		if err := ts.parentView(namespace.RootNamespace).Put(namespace.RootContext(nil), le); err != nil {
 			t.Fatalf("err: %v", err)
 		}
 	}
 
-	err := ts.revokeTree(namespace.TestContext(), &leaseEntry{})
+	err := ts.revokeTree(namespace.RootContext(nil), &leaseEntry{})
 	if err.Error() != "cannot tree-revoke blank token" {
 		t.Fatal(err)
 	}
 
-	saltCtx := namespace.TestContext()
+	saltCtx := namespace.RootContext(nil)
 	saltedID, err := c.tokenStore.SaltID(saltCtx, root.ID)
 	if err != nil {
 		t.Fatal(err)
 	}
 	tokenLeaseID := path.Join(root.Path, saltedID)
 
-	tokenLease, err := ts.expiration.loadEntry(namespace.TestContext(), tokenLeaseID)
+	tokenLease, err := ts.expiration.loadEntry(namespace.RootContext(nil), tokenLeaseID)
 	if err != nil || tokenLease == nil {
 		t.Fatalf("err: %v, tokenLease: %#v", err, tokenLease)
 	}
 
 	// Nuke tree non recursively.
-	err = ts.revokeTree(namespace.TestContext(), tokenLease)
+	err = ts.revokeTree(namespace.RootContext(nil), tokenLease)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1246,7 +1246,7 @@ func testTokenStore_RevokeTree_NonRecursive(t testing.TB, depth uint64, injectCy
 	// deleted.
 	children = append(children, root)
 	for _, entry := range children {
-		out, err := ts.Lookup(namespace.TestContext(), entry.ID)
+		out, err := ts.Lookup(namespace.RootContext(nil), entry.ID)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -1256,7 +1256,7 @@ func testTokenStore_RevokeTree_NonRecursive(t testing.TB, depth uint64, injectCy
 	}
 
 	for _, path := range cyclePaths {
-		entry, err := ts.parentView(namespace.TestNamespace()).Get(namespace.TestContext(), path)
+		entry, err := ts.parentView(namespace.RootNamespace).Get(namespace.RootContext(nil), path)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -1351,7 +1351,7 @@ func TestTokenStore_RevokeSelf(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "revoke-self")
 	req.ClientToken = ent1.ID
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -1361,7 +1361,7 @@ func TestTokenStore_RevokeSelf(t *testing.T) {
 	for _, id := range lookup {
 		var found bool
 		for i := 0; i < 10; i++ {
-			out, err = ts.Lookup(namespace.TestContext(), id)
+			out, err = ts.Lookup(namespace.RootContext(nil), id)
 			if err != nil {
 				t.Fatalf("err: %v", err)
 			}
@@ -1385,14 +1385,14 @@ func TestTokenStore_HandleRequest_NonAssignable(t *testing.T) {
 	req.ClientToken = root
 	req.Data["policies"] = []string{"default", "foo"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
 
 	req.Data["policies"] = []string{"default", "foo", responseWrappingPolicyName}
 
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1405,7 +1405,7 @@ func TestTokenStore_HandleRequest_NonAssignable(t *testing.T) {
 
 	// Batch tokens too
 	req.Data["type"] = "batch"
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1425,7 +1425,7 @@ func TestTokenStore_HandleRequest_CreateToken_DisplayName(t *testing.T) {
 	req.ClientToken = root
 	req.Data["display_name"] = "foo_bar.baz!"
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -1441,7 +1441,7 @@ func TestTokenStore_HandleRequest_CreateToken_DisplayName(t *testing.T) {
 		TTL:         0,
 		Type:        logical.TokenTypeService,
 	}
-	out, err := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, err := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1462,13 +1462,13 @@ func TestTokenStore_HandleRequest_CreateToken_NumUses(t *testing.T) {
 
 	// Make sure batch tokens can't do limited use counts
 	req.Data["type"] = "batch"
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if resp == nil || !resp.IsError() {
 		t.Fatalf("expected error: resp: %#v", resp)
 	}
 
 	delete(req.Data, "type")
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -1485,7 +1485,7 @@ func TestTokenStore_HandleRequest_CreateToken_NumUses(t *testing.T) {
 		TTL:         0,
 		Type:        logical.TokenTypeService,
 	}
-	out, err := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, err := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1504,7 +1504,7 @@ func TestTokenStore_HandleRequest_CreateToken_NumUses_Invalid(t *testing.T) {
 	req.ClientToken = root
 	req.Data["num_uses"] = "-1"
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v resp: %#v", err, resp)
 	}
@@ -1518,14 +1518,14 @@ func TestTokenStore_HandleRequest_CreateToken_NumUses_Restricted(t *testing.T) {
 	req.ClientToken = root
 	req.Data["num_uses"] = "1"
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
 
 	// We should NOT be able to use the restricted token to create a new token
 	req.ClientToken = resp.Auth.ClientToken
-	_, err = ts.HandleRequest(namespace.TestContext(), req)
+	_, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v resp: %#v", err, resp)
 	}
@@ -1540,13 +1540,13 @@ func TestTokenStore_HandleRequest_CreateToken_NoPolicy(t *testing.T) {
 
 	// Make sure batch tokens won't automatically assign root
 	req.Data["type"] = "batch"
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if resp == nil || !resp.IsError() {
 		t.Fatalf("expected error: resp: %#v", resp)
 	}
 
 	delete(req.Data, "type")
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -1562,7 +1562,7 @@ func TestTokenStore_HandleRequest_CreateToken_NoPolicy(t *testing.T) {
 		TTL:         0,
 		Type:        logical.TokenTypeService,
 	}
-	out, err := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, err := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -1580,7 +1580,7 @@ func TestTokenStore_HandleRequest_CreateToken_BadParent(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "create")
 	req.ClientToken = "random"
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v resp: %#v", err, resp)
 	}
@@ -1597,7 +1597,7 @@ func TestTokenStore_HandleRequest_CreateToken(t *testing.T) {
 	req.ClientToken = root
 	req.Data["policies"] = []string{"foo"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -1615,7 +1615,7 @@ func TestTokenStore_HandleRequest_CreateToken_RootID(t *testing.T) {
 	req.Data["id"] = "foobar"
 	req.Data["policies"] = []string{"foo"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -1625,11 +1625,11 @@ func TestTokenStore_HandleRequest_CreateToken_RootID(t *testing.T) {
 
 	// Retry with batch; batch should not actually accept a custom ID
 	req.Data["type"] = "batch"
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
-	out, _ := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, _ := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if out.ID == "foobar" {
 		t.Fatalf("bad: %#v", out)
 	}
@@ -1645,7 +1645,7 @@ func TestTokenStore_HandleRequest_CreateToken_NonRootID(t *testing.T) {
 	req.Data["id"] = "foobar"
 	req.Data["policies"] = []string{"foo"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v resp: %#v", err, resp)
 	}
@@ -1655,7 +1655,7 @@ func TestTokenStore_HandleRequest_CreateToken_NonRootID(t *testing.T) {
 
 	// Retry with batch
 	req.Data["type"] = "batch"
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v resp: %#v", err, resp)
 	}
@@ -1673,7 +1673,7 @@ func TestTokenStore_HandleRequest_CreateToken_NonRoot_Subset(t *testing.T) {
 	req.ClientToken = "client"
 	req.Data["policies"] = []string{"foo"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -1689,7 +1689,7 @@ func TestTokenStore_HandleRequest_CreateToken_NonRoot_Subset(t *testing.T) {
 	}
 	testMakeTokenDirectly(t, ts, ent)
 	req.ClientToken = ent.ID
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -1707,7 +1707,7 @@ func TestTokenStore_HandleRequest_CreateToken_NonRoot_InvalidSubset(t *testing.T
 	req.ClientToken = "client"
 	req.Data["policies"] = []string{"foo", "bar", "baz"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v resp: %#v", err, resp)
 	}
@@ -1723,7 +1723,7 @@ func TestTokenStore_HandleRequest_CreateToken_NonRoot_RootChild(t *testing.T) {
 
 	policy, _ := ParseACLPolicy(namespace.RootNamespace, tokenCreationPolicy)
 	policy.Name = "test1"
-	if err := ps.SetPolicy(namespace.TestContext(), policy); err != nil {
+	if err := ps.SetPolicy(namespace.RootContext(nil), policy); err != nil {
 		t.Fatal(err)
 	}
 
@@ -1734,7 +1734,7 @@ func TestTokenStore_HandleRequest_CreateToken_NonRoot_RootChild(t *testing.T) {
 	req.MountPoint = "auth/token/"
 	req.Data["policies"] = []string{"root"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v; resp: %#v", err, resp)
 	}
@@ -1756,7 +1756,7 @@ func TestTokenStore_HandleRequest_CreateToken_Root_RootChild_NoExpiry_Expiry(t *
 		"ttl": "5m",
 	}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v; resp: %#v", err, resp)
 	}
@@ -1774,7 +1774,7 @@ func TestTokenStore_HandleRequest_CreateToken_Root_RootChild_NoExpiry_Expiry(t *
 	req.Data = map[string]interface{}{
 		"ttl": "0",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil {
 		t.Fatalf("expected error")
 	}
@@ -1787,7 +1787,7 @@ func TestTokenStore_HandleRequest_CreateToken_Root_RootChild(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "create")
 	req.ClientToken = root
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("err: %v; resp: %#v", err, resp)
 	}
@@ -1809,7 +1809,7 @@ func TestTokenStore_HandleRequest_CreateToken_NonRoot_NoParent(t *testing.T) {
 	req.Data["no_parent"] = true
 	req.Data["policies"] = []string{"foo"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("err: %v resp: %#v", err, resp)
 	}
@@ -1832,7 +1832,7 @@ func TestTokenStore_HandleRequest_CreateToken_Root_NoParent(t *testing.T) {
 		t.Fatalf("bad: %#v", resp)
 	}
 
-	out, _ := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, _ := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if out.Parent != "" {
 		t.Fatalf("bad: %#v", out)
 	}
@@ -1852,7 +1852,7 @@ func TestTokenStore_HandleRequest_CreateToken_PathBased_NoParent(t *testing.T) {
 		t.Fatalf("bad: %#v", resp)
 	}
 
-	out, _ := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, _ := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if out.Parent != "" {
 		t.Fatalf("bad: %#v", out)
 	}
@@ -1876,7 +1876,7 @@ func TestTokenStore_HandleRequest_CreateToken_Metadata(t *testing.T) {
 		t.Fatalf("bad: %#v", resp)
 	}
 
-	out, _ := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, _ := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if !reflect.DeepEqual(out.Meta, meta) {
 		t.Fatalf("bad: expected:%#v\nactual:%#v", meta, out.Meta)
 	}
@@ -1888,7 +1888,7 @@ func TestTokenStore_HandleRequest_CreateToken_Metadata(t *testing.T) {
 		t.Fatalf("bad: %#v", resp)
 	}
 
-	out, _ = ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, _ = ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if !reflect.DeepEqual(out.Meta, meta) {
 		t.Fatalf("bad: expected:%#v\nactual:%#v", meta, out.Meta)
 	}
@@ -1953,12 +1953,12 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 	exp := mockExpiration(t)
 	ts := exp.tokenStore
 
-	rootToken, err := ts.rootToken(namespace.TestContext())
+	rootToken, err := ts.rootToken(namespace.RootContext(nil))
 	root := rootToken.ID
 
 	testMakeServiceTokenViaBackend(t, ts, root, "child", "", []string{"root", "foo"})
 
-	te, err := ts.Lookup(namespace.TestContext(), "child")
+	te, err := ts.Lookup(namespace.RootContext(nil), "child")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1973,14 +1973,14 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 			Renewable: true,
 		},
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	testMakeServiceTokenViaBackend(t, ts, "child", "sub-child", "", []string{"foo"})
 
-	te, err = ts.Lookup(namespace.TestContext(), "sub-child")
+	te, err = ts.Lookup(namespace.RootContext(nil), "sub-child")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1995,7 +1995,7 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 			Renewable: true,
 		},
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2004,7 +2004,7 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"token": "child",
 	}
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2014,7 +2014,7 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 
 	time.Sleep(200 * time.Millisecond)
 
-	out, err := ts.Lookup(namespace.TestContext(), "child")
+	out, err := ts.Lookup(namespace.RootContext(nil), "child")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2023,7 +2023,7 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 	}
 
 	// Sub-child should not exist
-	out, err = ts.Lookup(namespace.TestContext(), "sub-child")
+	out, err = ts.Lookup(namespace.RootContext(nil), "sub-child")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2039,7 +2039,7 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"token": "child",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2049,7 +2049,7 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 
 	time.Sleep(200 * time.Millisecond)
 
-	out, err = ts.Lookup(namespace.TestContext(), "child")
+	out, err = ts.Lookup(namespace.RootContext(nil), "child")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2058,7 +2058,7 @@ func TestTokenStore_HandleRequest_Revoke(t *testing.T) {
 	}
 
 	// Sub-child should not exist
-	out, err = ts.Lookup(namespace.TestContext(), "sub-child")
+	out, err = ts.Lookup(namespace.RootContext(nil), "sub-child")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2078,7 +2078,7 @@ func TestTokenStore_HandleRequest_RevokeOrphan(t *testing.T) {
 		"token": "child",
 	}
 	req.ClientToken = root
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2088,7 +2088,7 @@ func TestTokenStore_HandleRequest_RevokeOrphan(t *testing.T) {
 
 	time.Sleep(200 * time.Millisecond)
 
-	out, err := ts.Lookup(namespace.TestContext(), "child")
+	out, err := ts.Lookup(namespace.RootContext(nil), "child")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2097,11 +2097,11 @@ func TestTokenStore_HandleRequest_RevokeOrphan(t *testing.T) {
 	}
 
 	// Check that the parent entry is properly cleaned up
-	saltedID, err := ts.SaltID(namespace.TestContext(), "child")
+	saltedID, err := ts.SaltID(namespace.RootContext(nil), "child")
 	if err != nil {
 		t.Fatal(err)
 	}
-	children, err := ts.idView(namespace.RootNamespace).List(namespace.TestContext(), parentPrefix+saltedID+"/")
+	children, err := ts.idView(namespace.RootNamespace).List(namespace.RootContext(nil), parentPrefix+saltedID+"/")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2110,7 +2110,7 @@ func TestTokenStore_HandleRequest_RevokeOrphan(t *testing.T) {
 	}
 
 	// Sub-child should exist!
-	out, err = ts.Lookup(namespace.TestContext(), "sub-child")
+	out, err = ts.Lookup(namespace.RootContext(nil), "sub-child")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2124,7 +2124,7 @@ func TestTokenStore_HandleRequest_RevokeOrphan_NonRoot(t *testing.T) {
 	ts := c.tokenStore
 	testMakeServiceTokenViaBackend(t, ts, root, "child", "", []string{"foo"})
 
-	out, err := ts.Lookup(namespace.TestContext(), "child")
+	out, err := ts.Lookup(namespace.RootContext(nil), "child")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2137,7 +2137,7 @@ func TestTokenStore_HandleRequest_RevokeOrphan_NonRoot(t *testing.T) {
 		"token": "child",
 	}
 	req.ClientToken = "child"
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != logical.ErrInvalidRequest {
 		t.Fatalf("did not get error when non-root revoking itself with orphan flag; resp is %#v", resp)
 	}
@@ -2145,7 +2145,7 @@ func TestTokenStore_HandleRequest_RevokeOrphan_NonRoot(t *testing.T) {
 	time.Sleep(200 * time.Millisecond)
 
 	// Should still exist
-	out, err = ts.Lookup(namespace.TestContext(), "child")
+	out, err = ts.Lookup(namespace.RootContext(nil), "child")
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2166,7 +2166,7 @@ func testTokenStore_HandleRequest_Lookup(t *testing.T, batch bool) {
 	req.Data = map[string]interface{}{
 		"token": root,
 	}
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2215,7 +2215,7 @@ func testTokenStore_HandleRequest_Lookup(t *testing.T, batch bool) {
 	req.Data = map[string]interface{}{
 		"token": expID,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2267,7 +2267,7 @@ func testTokenStore_HandleRequest_Lookup(t *testing.T, batch bool) {
 	req.Data = map[string]interface{}{
 		"token": expID,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2319,7 +2319,7 @@ func testTokenStore_HandleRequest_Lookup(t *testing.T, batch bool) {
 	req.Data = map[string]interface{}{
 		"token": expID,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2331,7 +2331,7 @@ func testTokenStore_HandleRequest_Lookup(t *testing.T, batch bool) {
 	}
 
 	req.Path = "lookup"
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2355,7 +2355,7 @@ func TestTokenStore_HandleRequest_LookupSelf(t *testing.T) {
 
 	req := logical.TestRequest(t, logical.ReadOperation, "lookup-self")
 	req.ClientToken = "client"
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2408,7 +2408,7 @@ func TestTokenStore_HandleRequest_Renew(t *testing.T) {
 	ts := exp.tokenStore
 
 	// Create new token
-	root, err := ts.rootToken(namespace.TestContext())
+	root, err := ts.rootToken(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2421,7 +2421,7 @@ func TestTokenStore_HandleRequest_Renew(t *testing.T) {
 			Renewable: true,
 		},
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), root, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), root, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2437,7 +2437,7 @@ func TestTokenStore_HandleRequest_Renew(t *testing.T) {
 	}
 
 	req.Data["increment"] = "3600s"
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2457,7 +2457,7 @@ func TestTokenStore_HandleRequest_RenewSelf(t *testing.T) {
 	ts := exp.tokenStore
 
 	// Create new token
-	root, err := ts.rootToken(namespace.TestContext())
+	root, err := ts.rootToken(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2470,7 +2470,7 @@ func TestTokenStore_HandleRequest_RenewSelf(t *testing.T) {
 			Renewable: true,
 		},
 	}
-	err = exp.RegisterAuth(namespace.TestContext(), root, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), root, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2482,7 +2482,7 @@ func TestTokenStore_HandleRequest_RenewSelf(t *testing.T) {
 	req := logical.TestRequest(t, logical.UpdateOperation, "renew-self")
 	req.ClientToken = auth.ClientToken
 	req.Data["increment"] = "3600s"
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2503,7 +2503,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 	req := logical.TestRequest(t, logical.ReadOperation, "auth/token/roles/test")
 	req.ClientToken = root
 
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2520,7 +2520,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 		"path_suffix":      "happenin",
 	}
 
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2532,7 +2532,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 	req.Operation = logical.ReadOperation
 	req.Data = map[string]interface{}{}
 
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2567,7 +2567,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 		"renewable":        false,
 	}
 
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2579,7 +2579,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 	req.Operation = logical.ReadOperation
 	req.Data = map[string]interface{}{}
 
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2609,7 +2609,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 		"explicit_max_ttl": "5",
 		"period":           "0s",
 	}
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2617,7 +2617,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 	req.Operation = logical.ReadOperation
 	req.Data = map[string]interface{}{}
 
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2644,7 +2644,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 	req.Operation = logical.ListOperation
 	req.Path = "auth/token/roles"
 	req.Data = map[string]interface{}{}
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2668,7 +2668,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 
 	req.Operation = logical.DeleteOperation
 	req.Path = "auth/token/roles/test"
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2677,7 +2677,7 @@ func TestTokenStore_RoleCRUD(t *testing.T) {
 	}
 
 	req.Operation = logical.ReadOperation
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2702,13 +2702,13 @@ func TestTokenStore_RoleDisallowedPoliciesWithRoot(t *testing.T) {
 		},
 		ClientToken: root,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
 
 	roleReq.Operation = logical.ReadOperation
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -2731,19 +2731,19 @@ func TestTokenStore_RoleDisallowedPolicies(t *testing.T) {
 	// Create 3 different policies
 	policy, _ := ParseACLPolicy(namespace.RootNamespace, tokenCreationPolicy)
 	policy.Name = "test1"
-	if err := ps.SetPolicy(namespace.TestContext(), policy); err != nil {
+	if err := ps.SetPolicy(namespace.RootContext(nil), policy); err != nil {
 		t.Fatal(err)
 	}
 
 	policy, _ = ParseACLPolicy(namespace.RootNamespace, tokenCreationPolicy)
 	policy.Name = "test2"
-	if err := ps.SetPolicy(namespace.TestContext(), policy); err != nil {
+	if err := ps.SetPolicy(namespace.RootContext(nil), policy); err != nil {
 		t.Fatal(err)
 	}
 
 	policy, _ = ParseACLPolicy(namespace.RootNamespace, tokenCreationPolicy)
 	policy.Name = "test3"
-	if err := ps.SetPolicy(namespace.TestContext(), policy); err != nil {
+	if err := ps.SetPolicy(namespace.RootContext(nil), policy); err != nil {
 		t.Fatal(err)
 	}
 
@@ -2753,7 +2753,7 @@ func TestTokenStore_RoleDisallowedPolicies(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"disallowed_policies": "test1",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -2763,7 +2763,7 @@ func TestTokenStore_RoleDisallowedPolicies(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"disallowed_policies": "test2,test3",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -2773,7 +2773,7 @@ func TestTokenStore_RoleDisallowedPolicies(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"disallowed_policies": "test1,test2,test3",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -2793,21 +2793,21 @@ func TestTokenStore_RoleDisallowedPolicies(t *testing.T) {
 
 	req = logical.TestRequest(t, logical.UpdateOperation, "create/test1")
 	req.ClientToken = parentToken
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil || resp != nil && !resp.IsError() {
 		t.Fatalf("expected an error response, got %#v", resp)
 	}
 
 	req = logical.TestRequest(t, logical.UpdateOperation, "create/test23")
 	req.ClientToken = parentToken
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil || resp != nil && !resp.IsError() {
 		t.Fatalf("expected an error response, got %#v", resp)
 	}
 
 	req = logical.TestRequest(t, logical.UpdateOperation, "create/test123")
 	req.ClientToken = parentToken
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil || resp != nil && !resp.IsError() {
 		t.Fatalf("expected an error response, got %#v", resp)
 	}
@@ -2825,14 +2825,14 @@ func TestTokenStore_RoleDisallowedPolicies(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"disallowed_policies": "default",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
 
 	req = logical.TestRequest(t, logical.UpdateOperation, "create/default")
 	req.ClientToken = parentToken
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil || resp != nil && !resp.IsError() {
 		t.Fatal("expected an error response")
 	}
@@ -2848,7 +2848,7 @@ func TestTokenStore_RoleAllowedPolicies(t *testing.T) {
 		"allowed_policies": "test1,test2",
 	}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2860,7 +2860,7 @@ func TestTokenStore_RoleAllowedPolicies(t *testing.T) {
 
 	req.Path = "create/test"
 	req.Data["policies"] = []string{"foo"}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil {
 		t.Fatalf("expected error")
 	}
@@ -2877,7 +2877,7 @@ func TestTokenStore_RoleAllowedPolicies(t *testing.T) {
 	req.Data = map[string]interface{}{
 		"allowed_policies": "",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2905,7 +2905,7 @@ func TestTokenStore_RoleAllowedPolicies(t *testing.T) {
 
 	req.Path = "create/test"
 	req.Data["policies"] = []string{"foo"}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err == nil {
 		t.Fatalf("expected error")
 	}
@@ -2936,7 +2936,7 @@ func TestTokenStore_RoleOrphan(t *testing.T) {
 		"orphan": true,
 	}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2945,7 +2945,7 @@ func TestTokenStore_RoleOrphan(t *testing.T) {
 	}
 
 	req.Path = "create/test"
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2953,7 +2953,7 @@ func TestTokenStore_RoleOrphan(t *testing.T) {
 		t.Fatalf("bad: %#v", resp)
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, err := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -2977,7 +2977,7 @@ func TestTokenStore_RolePathSuffix(t *testing.T) {
 		"path_suffix": "happenin",
 	}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2987,7 +2987,7 @@ func TestTokenStore_RolePathSuffix(t *testing.T) {
 
 	req.Path = "create/test"
 	req.Operation = logical.UpdateOperation
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -2995,7 +2995,7 @@ func TestTokenStore_RolePathSuffix(t *testing.T) {
 		t.Fatalf("bad: %#v", resp)
 	}
 
-	out, err := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	out, err := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -3020,7 +3020,7 @@ func TestTokenStore_RolePeriod(t *testing.T) {
 		"period": 5,
 	}
 
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -3037,7 +3037,7 @@ func TestTokenStore_RolePeriod(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"policies": []string{"default"},
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
@@ -3048,7 +3048,7 @@ func TestTokenStore_RolePeriod(t *testing.T) {
 		req.ClientToken = resp.Auth.ClientToken
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3062,14 +3062,14 @@ func TestTokenStore_RolePeriod(t *testing.T) {
 
 		req.Operation = logical.UpdateOperation
 		req.Path = "auth/token/renew-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3085,14 +3085,14 @@ func TestTokenStore_RolePeriod(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 1,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3108,7 +3108,7 @@ func TestTokenStore_RolePeriod(t *testing.T) {
 		req.ClientToken = root
 		req.Operation = logical.UpdateOperation
 		req.Path = "auth/token/create/test"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
@@ -3125,7 +3125,7 @@ func TestTokenStore_RolePeriod(t *testing.T) {
 		req.ClientToken = resp.Auth.ClientToken
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3142,14 +3142,14 @@ func TestTokenStore_RolePeriod(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 1,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3176,7 +3176,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		"explicit_max_ttl": "100h",
 	}
 
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -3186,7 +3186,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 
 	req.Operation = logical.UpdateOperation
 	req.Path = "auth/token/create/test"
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatalf("expected an error")
 	}
@@ -3201,7 +3201,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		"explicit_max_ttl": "10s",
 	}
 
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -3217,7 +3217,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"policies": []string{"default"},
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
@@ -3228,7 +3228,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		req.ClientToken = resp.Auth.ClientToken
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3242,14 +3242,14 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 
 		req.Operation = logical.UpdateOperation
 		req.Path = "auth/token/renew-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3265,7 +3265,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		req.ClientToken = root
 		req.Operation = logical.UpdateOperation
 		req.Path = "auth/token/create/test"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
@@ -3282,7 +3282,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		req.ClientToken = resp.Auth.ClientToken
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3304,14 +3304,14 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 300,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3328,14 +3328,14 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 300,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3352,7 +3352,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 300,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err == nil {
 			t.Fatalf("expected error")
 		}
@@ -3361,7 +3361,7 @@ func TestTokenStore_RoleExplicitMaxTTL(t *testing.T) {
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if resp != nil && err == nil {
 			t.Fatalf("expected error, response is %#v", *resp)
 		}
@@ -3386,7 +3386,7 @@ func TestTokenStore_Periodic(t *testing.T) {
 		"period": 5,
 	}
 
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -3399,7 +3399,7 @@ func TestTokenStore_Periodic(t *testing.T) {
 		req.ClientToken = root
 		req.Operation = logical.UpdateOperation
 		req.Path = "auth/token/create"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -3416,7 +3416,7 @@ func TestTokenStore_Periodic(t *testing.T) {
 		req.ClientToken = resp.Auth.ClientToken
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3433,14 +3433,14 @@ func TestTokenStore_Periodic(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 1,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3460,7 +3460,7 @@ func TestTokenStore_Periodic(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"period": 5,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
@@ -3477,7 +3477,7 @@ func TestTokenStore_Periodic(t *testing.T) {
 		req.ClientToken = resp.Auth.ClientToken
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3494,14 +3494,14 @@ func TestTokenStore_Periodic(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 1,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3527,7 +3527,7 @@ func TestTokenStore_Periodic_ExplicitMax(t *testing.T) {
 		"period": 5,
 	}
 
-	resp, err := core.HandleRequest(namespace.TestContext(), req)
+	resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -3544,7 +3544,7 @@ func TestTokenStore_Periodic_ExplicitMax(t *testing.T) {
 			"period":           5,
 			"explicit_max_ttl": 4,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -3561,7 +3561,7 @@ func TestTokenStore_Periodic_ExplicitMax(t *testing.T) {
 		req.ClientToken = resp.Auth.ClientToken
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3578,14 +3578,14 @@ func TestTokenStore_Periodic_ExplicitMax(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 76,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3607,7 +3607,7 @@ func TestTokenStore_Periodic_ExplicitMax(t *testing.T) {
 			"explicit_max_ttl": 4,
 		}
 
-		resp, err := core.HandleRequest(namespace.TestContext(), req)
+		resp, err := core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
@@ -3618,7 +3618,7 @@ func TestTokenStore_Periodic_ExplicitMax(t *testing.T) {
 		req.ClientToken = root
 		req.Operation = logical.UpdateOperation
 		req.Path = "auth/token/create/test"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
@@ -3635,7 +3635,7 @@ func TestTokenStore_Periodic_ExplicitMax(t *testing.T) {
 		req.ClientToken = resp.Auth.ClientToken
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3652,14 +3652,14 @@ func TestTokenStore_Periodic_ExplicitMax(t *testing.T) {
 		req.Data = map[string]interface{}{
 			"increment": 1,
 		}
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err: %v\nresp: %#v", err, resp)
 		}
 
 		req.Operation = logical.ReadOperation
 		req.Path = "auth/token/lookup-self"
-		resp, err = core.HandleRequest(namespace.TestContext(), req)
+		resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %v", err)
 		}
@@ -3679,7 +3679,7 @@ func TestTokenStore_NoDefaultPolicy(t *testing.T) {
 	ps := core.policyStore
 	policy, _ := ParseACLPolicy(namespace.RootNamespace, tokenCreationPolicy)
 	policy.Name = "policy1"
-	if err := ps.SetPolicy(namespace.TestContext(), policy); err != nil {
+	if err := ps.SetPolicy(namespace.RootContext(nil), policy); err != nil {
 		t.Fatal(err)
 	}
 
@@ -3766,7 +3766,7 @@ func TestTokenStore_NoDefaultPolicy(t *testing.T) {
 		Path:        "roles/role1",
 		Operation:   logical.CreateOperation,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
@@ -3774,7 +3774,7 @@ func TestTokenStore_NoDefaultPolicy(t *testing.T) {
 	tokenReq.Data = map[string]interface{}{
 		"policies": []string{"policy1"},
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), tokenReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tokenReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
@@ -3789,7 +3789,7 @@ func TestTokenStore_NoDefaultPolicy(t *testing.T) {
 	roleReq.Data = map[string]interface{}{
 		"allowed_policies": "policy1",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
@@ -3807,7 +3807,7 @@ func TestTokenStore_NoDefaultPolicy(t *testing.T) {
 		"allowed_policies":    "policy1",
 		"disallowed_policies": "default",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
@@ -3821,7 +3821,7 @@ func TestTokenStore_NoDefaultPolicy(t *testing.T) {
 		"allowed_policies":    "",
 		"disallowed_policies": "default",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
@@ -3836,13 +3836,13 @@ func TestTokenStore_NoDefaultPolicy(t *testing.T) {
 		"allowed_policies":    "default",
 		"disallowed_policies": "default",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
 
 	delete(tokenReq.Data, "policies")
-	resp, err = ts.HandleRequest(namespace.TestContext(), tokenReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tokenReq)
 	if err == nil || (resp != nil && !resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
@@ -3864,7 +3864,7 @@ func TestTokenStore_AllowedDisallowedPolicies(t *testing.T) {
 			"disallowed_policies": "disallowed1,disallowed2",
 		},
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
@@ -3877,7 +3877,7 @@ func TestTokenStore_AllowedDisallowedPolicies(t *testing.T) {
 			"policies": []string{"allowed1"},
 		},
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), tokenReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tokenReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -3897,7 +3897,7 @@ func TestTokenStore_AllowedDisallowedPolicies(t *testing.T) {
 			"no_default_policy": true,
 		},
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), tokenReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tokenReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -3910,7 +3910,7 @@ func TestTokenStore_AllowedDisallowedPolicies(t *testing.T) {
 	tokenReq.Data = map[string]interface{}{
 		"policies": []string{"disallowed1"},
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), tokenReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tokenReq)
 	if err == nil {
 		t.Fatalf("expected an error")
 	}
@@ -3920,7 +3920,7 @@ func TestTokenStore_AllowedDisallowedPolicies(t *testing.T) {
 		"allowed_policies":    "allowed1,common",
 		"disallowed_policies": "disallowed1,common",
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), roleReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), roleReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v, resp: %v", err, resp)
 	}
@@ -3928,7 +3928,7 @@ func TestTokenStore_AllowedDisallowedPolicies(t *testing.T) {
 	tokenReq.Data = map[string]interface{}{
 		"policies": []string{"allowed1", "common"},
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), tokenReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tokenReq)
 	if err == nil {
 		t.Fatalf("expected an error")
 	}
@@ -3943,7 +3943,7 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 
 	exp := mockExpiration(t)
 	ts := exp.tokenStore
-	root, _ := exp.tokenStore.rootToken(namespace.TestContext())
+	root, _ := exp.tokenStore.rootToken(namespace.RootContext(nil))
 
 	tokenReq := &logical.Request{
 		Path:        "create",
@@ -3953,17 +3953,17 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 			"num_uses": 1,
 		},
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), tokenReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tokenReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
 
 	tut := resp.Auth.ClientToken
-	saltTut, err := ts.SaltID(namespace.TestContext(), tut)
+	saltTut, err := ts.SaltID(namespace.RootContext(nil), tut)
 	if err != nil {
 		t.Fatal(err)
 	}
-	te, err := ts.lookupInternal(namespace.TestContext(), saltTut, true, false)
+	te, err := ts.lookupInternal(namespace.RootContext(nil), saltTut, true, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -3974,7 +3974,7 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 		t.Fatalf("bad: %d", te.NumUses)
 	}
 
-	te, err = ts.UseToken(namespace.TestContext(), te)
+	te, err = ts.UseToken(namespace.RootContext(nil), te)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -3986,7 +3986,7 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 	}
 
 	// Should return no entry because it's tainted
-	te, err = ts.lookupInternal(namespace.TestContext(), saltTut, true, false)
+	te, err = ts.lookupInternal(namespace.RootContext(nil), saltTut, true, false)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4000,7 +4000,7 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 		ClientToken: tut,
 		Operation:   logical.UpdateOperation,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4012,7 +4012,7 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 	}
 
 	// Should return tainted entries
-	te, err = ts.lookupInternal(namespace.TestContext(), saltTut, true, true)
+	te, err = ts.lookupInternal(namespace.RootContext(nil), saltTut, true, true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4029,13 +4029,13 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 		return fmt.Errorf("keep it frosty")
 	}
 
-	err = ts.revokeInternal(namespace.TestContext(), saltTut, false)
+	err = ts.revokeInternal(namespace.RootContext(nil), saltTut, false)
 	if err == nil {
 		t.Fatalf("expected err")
 	}
 
 	// Since revocation failed we should still be able to get a token
-	te, err = ts.lookupInternal(namespace.TestContext(), saltTut, true, true)
+	te, err = ts.lookupInternal(namespace.RootContext(nil), saltTut, true, true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4052,7 +4052,7 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 
 	go func() {
 		cubbyFuncLock.RLock()
-		err := ts.revokeInternal(namespace.TestContext(), saltTut, false)
+		err := ts.revokeInternal(namespace.RootContext(nil), saltTut, false)
 		cubbyFuncLock.RUnlock()
 		if err == nil {
 			t.Fatalf("expected error")
@@ -4061,7 +4061,7 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 
 	// Give time for the function to start and grab locks
 	time.Sleep(200 * time.Millisecond)
-	te, err = ts.lookupInternal(namespace.TestContext(), saltTut, true, true)
+	te, err = ts.lookupInternal(namespace.RootContext(nil), saltTut, true, true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4077,12 +4077,12 @@ func TestTokenStore_RevokeUseCountToken(t *testing.T) {
 	defer cubbyFuncLock.Unlock()
 	ts.cubbyholeDestroyer = origDestroyCubbyhole
 
-	err = ts.revokeInternal(namespace.TestContext(), saltTut, false)
+	err = ts.revokeInternal(namespace.RootContext(nil), saltTut, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	te, err = ts.lookupInternal(namespace.TestContext(), saltTut, true, true)
+	te, err = ts.lookupInternal(namespace.RootContext(nil), saltTut, true, true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4107,7 +4107,7 @@ func TestTokenStore_HandleTidyCase1(t *testing.T) {
 		Path:        "accessors/",
 		ClientToken: root,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), accessorListReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), accessorListReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -4133,7 +4133,7 @@ func TestTokenStore_HandleTidyCase1(t *testing.T) {
 		// Creation of another token should end up with incrementing
 		// the number of accessors
 		// the storage
-		resp, err = ts.HandleRequest(namespace.TestContext(), accessorListReq)
+		resp, err = ts.HandleRequest(namespace.RootContext(nil), accessorListReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%v resp:%v", err, resp)
 		}
@@ -4149,29 +4149,29 @@ func TestTokenStore_HandleTidyCase1(t *testing.T) {
 		// cubbyhole and by not deleting its secondary index, its accessor and
 		// associated leases.
 
-		saltedTut, err := ts.SaltID(namespace.TestContext(), tut)
+		saltedTut, err := ts.SaltID(namespace.RootContext(nil), tut)
 		if err != nil {
 			t.Fatal(err)
 		}
-		te, err := ts.lookupInternal(namespace.TestContext(), saltedTut, true, true)
+		te, err := ts.lookupInternal(namespace.RootContext(nil), saltedTut, true, true)
 		if err != nil {
 			t.Fatalf("failed to lookup token: %v", err)
 		}
 
 		// Destroy the token index
-		if ts.idView(namespace.RootNamespace).Delete(namespace.TestContext(), saltedTut); err != nil {
+		if ts.idView(namespace.RootNamespace).Delete(namespace.RootContext(nil), saltedTut); err != nil {
 			t.Fatalf("failed to delete token entry: %v", err)
 		}
 
 		// Destroy the cubby space
-		err = ts.cubbyholeDestroyer(namespace.TestContext(), ts, te)
+		err = ts.cubbyholeDestroyer(namespace.RootContext(nil), ts, te)
 		if err != nil {
 			t.Fatalf("failed to destroyCubbyhole: %v", err)
 		}
 
 		// Leaking of accessor should have resulted in no change to the number
 		// of accessors
-		resp, err = ts.HandleRequest(namespace.TestContext(), accessorListReq)
+		resp, err = ts.HandleRequest(namespace.RootContext(nil), accessorListReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%v resp:%v", err, resp)
 		}
@@ -4187,7 +4187,7 @@ func TestTokenStore_HandleTidyCase1(t *testing.T) {
 		Operation:   logical.UpdateOperation,
 		ClientToken: root,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), tidyReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tidyReq)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4202,7 +4202,7 @@ func TestTokenStore_HandleTidyCase1(t *testing.T) {
 	time.Sleep(10 * time.Second)
 
 	// Tidy should have removed all the dangling accessor entries
-	resp, err = ts.HandleRequest(namespace.TestContext(), accessorListReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), accessorListReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -4231,7 +4231,7 @@ func TestTokenStore_HandleTidy_parentCleanup(t *testing.T) {
 		Path:        "accessors/",
 		ClientToken: root,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), accessorListReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), accessorListReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -4267,7 +4267,7 @@ func TestTokenStore_HandleTidy_parentCleanup(t *testing.T) {
 
 		// Creation of another token should end up with incrementing the number of
 		// accessors the storage
-		resp, err = ts.HandleRequest(namespace.TestContext(), accessorListReq)
+		resp, err = ts.HandleRequest(namespace.RootContext(nil), accessorListReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%v resp:%v", err, resp)
 		}
@@ -4283,29 +4283,29 @@ func TestTokenStore_HandleTidy_parentCleanup(t *testing.T) {
 		// cubbyhole and by not deleting its secondary index, its accessor and
 		// associated leases.
 
-		saltedTut, err := ts.SaltID(namespace.TestContext(), tut)
+		saltedTut, err := ts.SaltID(namespace.RootContext(nil), tut)
 		if err != nil {
 			t.Fatal(err)
 		}
-		te, err := ts.lookupInternal(namespace.TestContext(), saltedTut, true, true)
+		te, err := ts.lookupInternal(namespace.RootContext(nil), saltedTut, true, true)
 		if err != nil {
 			t.Fatalf("failed to lookup token: %v", err)
 		}
 
 		// Destroy the token index
-		if ts.idView(namespace.RootNamespace).Delete(namespace.TestContext(), saltedTut); err != nil {
+		if ts.idView(namespace.RootNamespace).Delete(namespace.RootContext(nil), saltedTut); err != nil {
 			t.Fatalf("failed to delete token entry: %v", err)
 		}
 
 		// Destroy the cubby space
-		err = ts.cubbyholeDestroyer(namespace.TestContext(), ts, te)
+		err = ts.cubbyholeDestroyer(namespace.RootContext(nil), ts, te)
 		if err != nil {
 			t.Fatalf("failed to destroyCubbyhole: %v", err)
 		}
 
 		// Leaking of accessor should have resulted in no change to the number
 		// of accessors
-		resp, err = ts.HandleRequest(namespace.TestContext(), accessorListReq)
+		resp, err = ts.HandleRequest(namespace.RootContext(nil), accessorListReq)
 		if err != nil || (resp != nil && resp.IsError()) {
 			t.Fatalf("err:%v resp:%v", err, resp)
 		}
@@ -4321,7 +4321,7 @@ func TestTokenStore_HandleTidy_parentCleanup(t *testing.T) {
 		Operation:   logical.UpdateOperation,
 		ClientToken: root,
 	}
-	resp, err = ts.HandleRequest(namespace.TestContext(), tidyReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), tidyReq)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4336,7 +4336,7 @@ func TestTokenStore_HandleTidy_parentCleanup(t *testing.T) {
 	time.Sleep(10 * time.Second)
 
 	// Tidy should have removed all the dangling accessor entries
-	resp, err = ts.HandleRequest(namespace.TestContext(), accessorListReq)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), accessorListReq)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err:%v resp:%v", err, resp)
 	}
@@ -4356,7 +4356,7 @@ func TestTokenStore_HandleTidy_parentCleanup(t *testing.T) {
 			"accessor": accessor,
 		}
 
-		resp, err := ts.HandleRequest(namespace.TestContext(), req)
+		resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 		if err != nil {
 			t.Fatalf("err: %s", err)
 		}
@@ -4387,7 +4387,7 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 	}
 
 	// Create new token
-	root, err := ts.rootToken(namespace.TestContext())
+	root, err := ts.rootToken(namespace.RootContext(nil))
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
@@ -4397,7 +4397,7 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 	req.ClientToken = root.ID
 	req.Data["policies"] = []string{"default"}
 
-	resp, err := ts.HandleRequest(namespace.TestContext(), req)
+	resp, err := ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil || (resp != nil && resp.IsError()) {
 		t.Fatalf("err: %v\nresp: %#v", err, resp)
 	}
@@ -4415,13 +4415,13 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 		NamespaceID: namespace.RootNamespaceID,
 	}
 
-	err = exp.RegisterAuth(namespace.TestContext(), te, auth)
+	err = exp.RegisterAuth(namespace.RootContext(nil), te, auth)
 	if err != nil {
 		t.Fatalf("err: %v", err)
 	}
 
 	// Verify token entry through lookup
-	testTokenEntry, err := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	testTokenEntry, err := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4448,7 +4448,7 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 	leases := []string{}
 
 	for i := 0; i < 10; i++ {
-		leaseID, err := exp.Register(namespace.TestContext(), req, resp)
+		leaseID, err := exp.Register(namespace.RootContext(nil), req, resp)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -4457,7 +4457,7 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 
 	sort.Strings(leases)
 
-	te, err = ts.lookupInternal(namespace.TestContext(), tut, false, true)
+	te, err = ts.lookupInternal(namespace.RootContext(nil), tut, false, true)
 	if err != nil {
 		t.Fatalf("failed to lookup token: %v", err)
 	}
@@ -4465,7 +4465,7 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 		t.Fatal("got nil token entry")
 	}
 
-	storedLeases, err := exp.lookupLeasesByToken(namespace.TestContext(), te)
+	storedLeases, err := exp.lookupLeasesByToken(namespace.RootContext(nil), te)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4475,11 +4475,11 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 	}
 
 	// Now, delete the token entry. The leases should still exist.
-	saltedTut, err := ts.SaltID(namespace.TestContext(), tut)
+	saltedTut, err := ts.SaltID(namespace.RootContext(nil), tut)
 	if err != nil {
 		t.Fatal(err)
 	}
-	te, err = ts.lookupInternal(namespace.TestContext(), saltedTut, true, true)
+	te, err = ts.lookupInternal(namespace.RootContext(nil), saltedTut, true, true)
 	if err != nil {
 		t.Fatalf("failed to lookup token: %v", err)
 	}
@@ -4488,10 +4488,10 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 	}
 
 	// Destroy the token index
-	if ts.idView(namespace.RootNamespace).Delete(namespace.TestContext(), saltedTut); err != nil {
+	if ts.idView(namespace.RootNamespace).Delete(namespace.RootContext(nil), saltedTut); err != nil {
 		t.Fatalf("failed to delete token entry: %v", err)
 	}
-	te, err = ts.lookupInternal(namespace.TestContext(), saltedTut, true, true)
+	te, err = ts.lookupInternal(namespace.RootContext(nil), saltedTut, true, true)
 	if err != nil {
 		t.Fatalf("failed to lookup token: %v", err)
 	}
@@ -4500,7 +4500,7 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 	}
 
 	// Verify leases still exist
-	storedLeases, err = exp.lookupLeasesByToken(namespace.TestContext(), testTokenEntry)
+	storedLeases, err = exp.lookupLeasesByToken(namespace.RootContext(nil), testTokenEntry)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4510,12 +4510,12 @@ func TestTokenStore_TidyLeaseRevocation(t *testing.T) {
 	}
 
 	// Call tidy
-	ts.handleTidy(namespace.TestContext(), &logical.Request{}, nil)
+	ts.handleTidy(namespace.RootContext(nil), &logical.Request{}, nil)
 
 	time.Sleep(200 * time.Millisecond)
 
 	// Verify leases are gone
-	storedLeases, err = exp.lookupLeasesByToken(namespace.TestContext(), testTokenEntry)
+	storedLeases, err = exp.lookupLeasesByToken(namespace.RootContext(nil), testTokenEntry)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4574,7 +4574,7 @@ func TestTokenStore_Batch_CannotRevoke(t *testing.T) {
 
 	req.Path = "revoke"
 	req.Data["token"] = resp.Auth.ClientToken
-	resp, err = ts.HandleRequest(namespace.TestContext(), req)
+	resp, err = ts.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4604,7 +4604,7 @@ func TestTokenStore_Batch_NoCubbyhole(t *testing.T) {
 		t.Fatalf("bad: policies: expected: [policy, default]; actual: %s", resp.Auth.Policies)
 	}
 
-	te, err := ts.Lookup(namespace.TestContext(), resp.Auth.ClientToken)
+	te, err := ts.Lookup(namespace.RootContext(nil), resp.Auth.ClientToken)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -4613,7 +4613,7 @@ func TestTokenStore_Batch_NoCubbyhole(t *testing.T) {
 	req.Operation = logical.CreateOperation
 	req.ClientToken = te.ID
 	req.SetTokenEntry(te)
-	resp, err = core.HandleRequest(namespace.TestContext(), req)
+	resp, err = core.HandleRequest(namespace.RootContext(nil), req)
 	if err != nil && !errwrap.Contains(err, logical.ErrInvalidRequest.Error()) {
 		t.Fatal(err)
 	}