| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // TODO(sadovsky): Enable once the server implementation has been updated to |
| // reflect the new Syncbase design. |
| // +build ignore |
| |
| package nosql_test |
| |
| // Note: v.io/x/ref/services/groups/internal/server/server_test.go has some |
| // helpful code snippets to model after. |
| |
| import ( |
| "reflect" |
| "runtime/debug" |
| "testing" |
| |
| wire "v.io/syncbase/v23/services/syncbase" |
| "v.io/syncbase/v23/syncbase" |
| "v.io/syncbase/v23/syncbase/common" |
| "v.io/syncbase/x/ref/services/syncbase/server" |
| "v.io/syncbase/x/ref/services/syncbase/store/memstore" |
| "v.io/v23" |
| "v.io/v23/context" |
| "v.io/v23/naming" |
| "v.io/v23/security" |
| "v.io/v23/security/access" |
| "v.io/v23/vdl" |
| "v.io/x/lib/vlog" |
| _ "v.io/x/ref/profiles" |
| tsecurity "v.io/x/ref/test/testutil" |
| ) |
| |
| func defaultPermissions() access.Permissions { |
| perms := access.Permissions{} |
| for _, tag := range access.AllTypicalTags() { |
| perms.Add(security.BlessingPattern("server/client"), string(tag)) |
| } |
| return perms |
| } |
| |
| func newServer(ctx *context.T, perms access.Permissions) (string, func()) { |
| s, err := v23.NewServer(ctx) |
| if err != nil { |
| vlog.Fatal("v23.NewServer() failed: ", err) |
| } |
| eps, err := s.Listen(v23.GetListenSpec(ctx)) |
| if err != nil { |
| vlog.Fatal("s.Listen() failed: ", err) |
| } |
| |
| service := server.NewService(memstore.New()) |
| if perms == nil { |
| perms = defaultPermissions() |
| } |
| if err := service.Create(perms); err != nil { |
| vlog.Fatal("service.Create() failed: ", err) |
| } |
| d := server.NewDispatcher(service) |
| |
| if err := s.ServeDispatcher("", d); err != nil { |
| vlog.Fatal("s.ServeDispatcher() failed: ", err) |
| } |
| |
| name := naming.JoinAddressName(eps[0].String(), "") |
| return name, func() { |
| s.Stop() |
| } |
| } |
| |
| func setupOrDie(perms access.Permissions) (clientCtx *context.T, serverName string, cleanup func()) { |
| ctx, shutdown := v23.Init() |
| cp, sp := tsecurity.NewPrincipal("client"), tsecurity.NewPrincipal("server") |
| |
| // Have the server principal bless the client principal as "client". |
| blessings, err := sp.Bless(cp.PublicKey(), sp.BlessingStore().Default(), "client", security.UnconstrainedUse()) |
| if err != nil { |
| vlog.Fatal("sp.Bless() failed: ", err) |
| } |
| // Have the client present its "client" blessing when talking to the server. |
| if _, err := cp.BlessingStore().Set(blessings, "server"); err != nil { |
| vlog.Fatal("cp.BlessingStore().Set() failed: ", err) |
| } |
| // Have the client treat the server's public key as an authority on all |
| // blessings that match the pattern "server". |
| if err := cp.AddToRoots(blessings); err != nil { |
| vlog.Fatal("cp.AddToRoots() failed: ", err) |
| } |
| |
| clientCtx, err = v23.SetPrincipal(ctx, cp) |
| if err != nil { |
| vlog.Fatal("v23.SetPrincipal() failed: ", err) |
| } |
| serverCtx, err := v23.SetPrincipal(ctx, sp) |
| if err != nil { |
| vlog.Fatal("v23.SetPrincipal() failed: ", err) |
| } |
| |
| serverName, stopServer := newServer(serverCtx, perms) |
| cleanup = func() { |
| stopServer() |
| shutdown() |
| } |
| return |
| } |
| |
| func getPermissionsOrDie(ac common.AccessController, ctx *context.T, t *testing.T) access.Permissions { |
| perms, _, err := ac.GetPermissions(ctx) |
| if err != nil { |
| debug.PrintStack() |
| t.Fatalf("GetPermissions failed: %s", err) |
| } |
| return perms |
| } |
| |
| // Inputs appName and dName are app and database names respectively. |
| func createDatabase(ctx *context.T, s syncbase.Service, appName, dName string, perms access.Permissions, schema wire.Schema) error { |
| a := s.App(appName) |
| if err := a.Create(ctx, perms); err != nil { |
| return err |
| } |
| return a.Database(dName).Create(ctx, perms) |
| } |
| |
| //////////////////////////////////////// |
| // Test cases |
| |
| // TODO(sadovsky): Finish writing tests. |
| |
| func TestNameAndKey(t *testing.T) { |
| a := syncbase.NewService("s").App("a") |
| d := a.Database("d") |
| tb := d.Table("tb") |
| r := tb.Row("r") |
| |
| if d.Name() != "d" { |
| t.Errorf("Wrong name: %s", d.Name()) |
| } |
| if tb.Name() != "tb" { |
| t.Errorf("Wrong name: %s", tb.Name()) |
| } |
| if r.Key() != "r" { |
| t.Errorf("Wrong key: %s", r.Key()) |
| } |
| } |
| |
| // Tests that Database.Create works as expected, including default Permissions. |
| func TestCreate(t *testing.T) { |
| ctx, sName, cleanup := setupOrDie(nil) |
| defer cleanup() |
| |
| s := syncbase.NewService(sName) |
| a := s.App("a") |
| d := a.Database("d") |
| |
| // Create the App. |
| if err := a.Create(ctx, nil); err != nil { |
| t.Fatalf("a.Create() failed: %s", err) |
| } |
| |
| // Create the Database. |
| // TODO(sadovsky): Test auth check (against App Permissions). |
| if err := d.Create(ctx, nil); err != nil { |
| t.Fatalf("d.Create() failed: %s", err) |
| } |
| if wantPermissions, gotPermissions := defaultPermissions(), getPermissionsOrDie(a, ctx, t); !reflect.DeepEqual(wantPermissions, gotPermissions) { |
| t.Errorf("Permissions do not match: want %v, got %v", wantPermissions, gotPermissions) |
| } |
| |
| // Test Database.Create with non-default Permissions. |
| d2 := a.Database("d2") |
| perms = access.Permissions{} |
| perms.Add(security.BlessingPattern("server/client"), string(access.Admin)) |
| if err := d2.Create(ctx, perms); err != nil { |
| t.Fatalf("d2.Create() failed: %s", err) |
| } |
| if wantPermissions, gotPermissions := perms, getPermissionsOrDie(d2, ctx, t); !reflect.DeepEqual(wantPermissions, gotPermissions) { |
| t.Errorf("Permissions do not match: want %v, got %v", wantPermissions, gotPermissions) |
| } |
| } |
| |
| // Tests that Database.Delete works as expected. |
| func TestDelete(t *testing.T) { |
| } |
| |
| // Tests that Database.{Create,Delete}Table work as expected. |
| func TestDelete(t *testing.T) { |
| } |
| |
| // Tests that the various {Set,Get}Permissions methods work as expected. |
| func TestPermissionsMethods(t *testing.T) { |
| } |
| |
| // Tests that Table.{Get,Put,Delete} work as expected. |
| func TestTableRowMethods(t *testing.T) { |
| } |
| |
| // Tests that Row.{Get,Put,Delete} work as expected. |
| func TestRowMethods(t *testing.T) { |
| } |