package main import ( "context" "errors" "strings" "testing" ) // The move (to-be 55 ยง8.1, AC53): a dry run writes nothing; the copy writes every version as an operation with the old // author kept apart; writes wait while it runs; the check names every difference; the switch is set only on a clean check; // from then on the ledger is served and the database written beside it, behind or not; run again nothing is copied twice. func TestTheMoveCopiesChecksAndSwitchesOnlyOnACleanCheck(t *testing.T) { ctx := context.Background() db := newMemStore() seed := imported(t, db) // the database holds the fixture's records, one version each n := seed.reserved(t, "author@g14") seed.accepted(t, "author@g14", valid(n)) f := newFakeLedger(t) states := newFakeStates() led := newLedgerStore(f, states) m := newMovableStore(db, led, states) w := newWorld(t, m, fixture()) w.k.States = states w.tracker.next[KindDecision] = n + 1 // the numbers seed took are spent if _, err := m.Move(ctx, MoveAsk{}, nil); err == nil { t.Fatal("a move that is neither a dry run nor a commit") } dry, err := m.Move(ctx, MoveAsk{DryRun: true}, nil) if err != nil || dry.Records < 10 || dry.Versions < dry.Records || len(f.applied) != 0 || m.Source() != SourceDatabase { t.Fatalf("%v %+v, %d operations", err, dry, len(f.applied)) } // Writes wait while the copy runs, and the copy says how far it is. refused := false m2 := newMovableStore(db, newLedgerStore(newFakeLedger(t), newFakeStates()), states) m2.moving = true if err := m2.Create(ctx, Version{Record: ledgerRecord(900, StatusReserved)}); errors.Is(err, ErrMoving) { refused = true } if !refused { t.Fatal("a write was taken while the records move") } // A difference stops the switch: a record changed in the database after the copy is named by the check. moved, err := m.Move(ctx, MoveAsk{Commit: true}, nil) if err != nil || !moved.Switched || len(moved.Problems) != 0 || m.Source() != SourceLedger || moved.Records != dry.Records { t.Fatalf("%v %+v", err, moved) } // The old author is kept apart, the module's account is the ledger's. var imports int for _, a := range f.applied { if a.Operation == OpImport { imports++ } } if imports < moved.Versions { t.Fatalf("%d import operations for %d versions", imports, moved.Versions) } last := f.hist[InstanceOf(Key{KindDecision, n})] if op := last[len(last)-1]; op.Operation != OpImport || op.Author.Account != "mesh-knowledge" || op.Author.Caller != "" || !strings.Contains(string(op.Body), `"imported-by":"the agent on test`) { t.Fatalf("the old author is not kept apart from the ledger's: %+v", op.Author) } // Run again: nothing is copied twice, and it is refused as the switch is set. if _, err := m.Move(ctx, MoveAsk{Commit: true}, nil); err == nil { t.Fatal("a second move was taken") } // Served from the ledger, and a write goes to both: the database is written beside it. before := len(f.applied) m2n := w.reserved(t, "author@g14") if len(f.applied) == before { t.Fatal("a reservation after the switch did not reach the ledger") } if e, _ := db.Get(ctx, Key{KindDecision, m2n}); e == nil { t.Fatal("the database is not written beside the ledger") } if diffs, err := m.Check(ctx); err != nil || len(diffs) != 0 { t.Fatalf("a check after the writes: %v %v", err, diffs) } // The database changed behind the ledger's back, and a write it refuses: the check names both. e, _ := db.Get(ctx, Key{KindDecision, n}) r := e.Current.Clone() r.Title = "Changed in the database only" if err := db.Save(ctx, Version{By: "x", At: w.clock, Why: "x", Record: r}, true, false, e.Revision); err != nil { t.Fatal(err) } diffs, _ := m.Check(ctx) if len(diffs) == 0 || !strings.Contains(strings.Join(diffs, "\n"), "ADR 0300") { t.Fatalf("the check missed a difference: %v", diffs) } } // A copy that is not clean leaves the database the source. func TestACopyThatIsNotCleanLeavesTheDatabaseTheSource(t *testing.T) { ctx := context.Background() db := newMemStore() imported(t, db) f := newFakeLedger(t) states := newFakeStates() m := newMovableStore(db, newLedgerStore(f, states), states) f.failApply = OpImport if _, err := m.Move(ctx, MoveAsk{Commit: true}, nil); err == nil || m.Source() != SourceDatabase { t.Fatalf("a copy the ledger refused switched: %v", err) } f.failApply = "" // A mirror the database refuses is written down: the ledger took the write, and the database is behind. if moved, err := m.Move(ctx, MoveAsk{Commit: true}, nil); err != nil || !moved.Switched { t.Fatalf("%v %+v", err, moved) } m.db = &failingSaves{memStore: db, key: Key{KindDecision, 11}, fail: true} e, _ := m.Get(ctx, Key{KindDecision, 11}) r := e.Current.Clone() r.Title = "Changed" if err := m.Save(ctx, Version{By: "x", Record: r, At: e.Current.AcceptedAt}, true, false, e.Revision); err != nil { t.Fatalf("the ledger's write is refused for the database's: %v", err) } if kv, _ := states.State(findingsState).Get(behindKey); kv == nil { t.Fatal("a database behind is not written down") } if diffs, _ := m.Check(ctx); !strings.Contains(strings.Join(diffs, "\n"), "database is behind") { t.Fatalf("%v", diffs) } }