| // Copyright 2016 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package internal |
| |
| import ( |
| "fmt" |
| "math/rand" |
| "testing" |
| "time" |
| |
| "google.golang.org/cloud/bigtable" |
| |
| "v.io/v23/naming" |
| "v.io/v23/security" |
| "v.io/v23/security/access" |
| "v.io/x/ref/test" |
| ) |
| |
| func TestMutations(t *testing.T) { |
| ctx, shutdown := test.V23Init() |
| defer shutdown() |
| |
| bt, shutdownBT, err := NewTestBigTable("test") |
| if err != nil { |
| t.Fatalf("NewTestBigTable: %s", err) |
| } |
| defer shutdownBT() |
| if err := bt.SetupTable(ctx, ""); err != nil { |
| t.Fatalf("bt.SetupTable: %s", err) |
| } |
| |
| root, err := getNode(ctx, bt, "") |
| if err != nil { |
| t.Fatalf("getNode: %v", err) |
| } |
| |
| ops := []func(i int, n *mtNode) bool{ |
| func(i int, n *mtNode) bool { |
| if err := n.delete(ctx, false); err != nil { |
| t.Logf("[%d] delete: %v", i, err) |
| return false |
| } |
| t.Logf("[%d] delete succeeded", i) |
| m, err := getNode(ctx, bt, "X") |
| if err != nil { |
| t.Errorf("[%d] getNode failed after delete: %v", i, err) |
| return false |
| } |
| if m != nil { |
| t.Errorf("[%d] node still exists after delete", i) |
| return false |
| } |
| return true |
| }, |
| func(i int, n *mtNode) bool { |
| if child, err := n.createChild(ctx, "Y", n.permissions, "", 0); err != nil { |
| t.Logf("[%d] createChild: (%v, %v)", i, child, err) |
| return false |
| } |
| t.Logf("[%d] createChild succeeded", i) |
| m, err := getNode(ctx, bt, "X") |
| if err != nil { |
| t.Errorf("[%d] getNode failed after createChild: %v", i, err) |
| return false |
| } |
| if m == nil { |
| t.Errorf("[%d] node doesn't exist after createChild", i) |
| return false |
| } |
| if len(m.children) != 1 || m.children[0].name() != "Y" { |
| t.Errorf("[%d] unexpected children after createChild: %v", i, m.children) |
| return false |
| } |
| return true |
| }, |
| func(i int, n *mtNode) bool { |
| const serverAddr = "/example.com:1234" |
| if err := n.mount(ctx, serverAddr, clock.Now().Add(time.Minute), 0, 0); err != nil { |
| t.Logf("[%d] mount: %v", i, err) |
| return false |
| } |
| t.Logf("[%d] mount succeeded", i) |
| m, err := getNode(ctx, bt, "X") |
| if err != nil { |
| t.Errorf("[%d] getNode failed after mount: %v", i, err) |
| return false |
| } |
| if m == nil { |
| t.Errorf("[%d] node doesn't exist after mount", i) |
| return false |
| } |
| if len(m.servers) != 1 || m.servers[0].Server != serverAddr { |
| t.Errorf("[%d] unexpected servers after mount: %v", i, m.servers) |
| return false |
| } |
| return true |
| }, |
| func(i int, n *mtNode) bool { |
| perm := access.Permissions{"Admin": access.AccessList{In: []security.BlessingPattern{"foo"}}} |
| if err := n.setPermissions(ctx, perm); err != nil { |
| t.Logf("[%d] setPermissions: %v", i, err) |
| return false |
| } |
| t.Logf("[%d] setPermissions succeeded", i) |
| m, err := getNode(ctx, bt, "X") |
| if err != nil { |
| t.Errorf("[%d] getNode failed after setPermissions: %v", i, err) |
| return false |
| } |
| if m == nil { |
| t.Errorf("[%d] node doesn't exist after setPermissions", i) |
| return false |
| } |
| if len(m.permissions["Admin"].In) != 1 || string(m.permissions["Admin"].In[0]) != "foo" { |
| t.Errorf("[%d] unexpected permissions after setPermissions: %v", i, m.permissions) |
| } |
| return true |
| }, |
| } |
| for i := 1; i <= 100; i++ { |
| // Create X. |
| root, _ = getNode(ctx, bt, "") |
| n, err := root.createChild(ctx, "X", root.permissions, "", 0) |
| if err != nil || n == nil { |
| t.Fatalf("createChild(X): (%v, %v)", n, err) |
| } |
| |
| // Attempt all the mutations in random order. Only the first one |
| // should ever succeed because the node version changes after |
| // successful mutations. |
| for j, p := range rand.Perm(len(ops)) { |
| success := ops[p](i, n) |
| switch { |
| case j == 0 && !success: |
| t.Errorf("Unexpected failure for first mutation") |
| case j > 0 && success: |
| t.Errorf("Unexpected success for mutation") |
| } |
| } |
| |
| // Delete X, if it still exists. |
| if n, err := getNode(ctx, bt, "X"); err == nil && n != nil { |
| n.delete(ctx, true) |
| } |
| } |
| |
| count, err := bt.CountRows(ctx) |
| if err != nil { |
| t.Errorf("CountRows failed: %v", err) |
| } |
| if expected := 1; count != expected { |
| t.Errorf("Unexpected number of rows: got %d, expected %d", count, expected) |
| bt.DumpTable(ctx) |
| } |
| } |
| |
| func TestFsck(t *testing.T) { |
| ctx, shutdown := test.V23Init() |
| defer shutdown() |
| |
| bt, shutdownBT, err := NewTestBigTable("test") |
| if err != nil { |
| t.Fatalf("NewTestBigTable: %s", err) |
| } |
| defer shutdownBT() |
| if err := bt.SetupTable(ctx, ""); err != nil { |
| t.Fatalf("bt.SetupTable: %s", err) |
| } |
| |
| checkRowCount := func(expected int) { |
| count, err := bt.CountRows(ctx) |
| if err != nil { |
| t.Errorf("CountRows failed: %v", err) |
| } |
| if count != expected { |
| t.Errorf("Unexpected number of rows: got %d, expected %d", count, expected) |
| } |
| } |
| |
| root, err := getNode(ctx, bt, "") |
| if err != nil { |
| t.Fatalf("getNode: %v", err) |
| } |
| |
| // Create a few children. |
| for i := 1; i <= 5; i++ { |
| if _, err := root.createChild(ctx, fmt.Sprintf("child%d", i), root.permissions, "", 0); err != nil { |
| t.Fatalf("createChild failed: %v", err) |
| } |
| if root, err = getNode(ctx, bt, ""); err != nil { |
| t.Fatalf("getNode: %v", err) |
| } |
| } |
| checkRowCount(6) |
| |
| // Create a few orphan rows. |
| for i := 1; i <= 5; i++ { |
| name := fmt.Sprintf("orphan%d", i) |
| childRef, err := newChild("XXXXXXXX", name) |
| if err != nil { |
| t.Fatalf("newChild failed: %v", err) |
| } |
| if err := bt.createRow(ctx, name, root.permissions, "", childRef, 0); err != nil { |
| t.Fatalf("createRow failed: %v", err) |
| } |
| if childRef, err = newChild("XXXXXXXX", "otherorphan"); err != nil { |
| t.Fatalf("newChild failed: %v", err) |
| } |
| if err := bt.createRow(ctx, naming.Join(name, childRef.name()), root.permissions, "", childRef, 0); err != nil { |
| t.Fatalf("createRow failed: %v", err) |
| } |
| for j := 1; j <= 5; j++ { |
| n, err := getNode(ctx, bt, name) |
| if err != nil { |
| t.Fatalf("getNode: %v", err) |
| } |
| if _, err := n.createChild(ctx, fmt.Sprintf("child%d", j), n.permissions, "", 0); err != nil { |
| t.Fatalf("createChild failed: %v", err) |
| } |
| } |
| } |
| checkRowCount(41) |
| |
| // Add reference to a row that doesn't exist. |
| mut := bigtable.NewMutation() |
| mut.Set(childrenFamily, "XXXXXXXXwhodat", bigtable.ServerTime, []byte{1}) |
| if err := bt.apply(ctx, rowKey("child1"), mut); err != nil { |
| t.Fatalf("unexpected failure: %v", err) |
| } |
| checkRowCount(41) |
| |
| if err := bt.Fsck(ctx, false); err == nil { |
| t.Errorf("Fsck did not find any inconsistencies") |
| } |
| if err := bt.Fsck(ctx, true); err != nil { |
| t.Errorf("Fsck failed: %v", err) |
| } |
| if err := bt.Fsck(ctx, false); err != nil { |
| t.Errorf("Fsck failed: %v", err) |
| } |
| |
| // root + 5 children |
| checkRowCount(6) |
| } |
