protocol/recover_test.go

   1 package protocol
   2
   3 import (
   4         "context"
   5         "log"
   6         "testing"
   7         "time"
   8
   9         "chain/protocol/bc"
  10         "chain/protocol/bc/legacy"
  11         "chain/protocol/prottest/memstore"
  12         "chain/protocol/state"
  13         "chain/testutil"
  14 )
  15
  16 func TestRecoverSnapshotNoAdditionalBlocks(t *testing.T) {
  17         store := memstore.New()
  18         b, err := NewInitialBlock(nil, 0, time.Now().Add(-time.Minute))
  19         if err != nil {
  20                 testutil.FatalErr(t, err)
  21         }
  22         c1, err := NewChain(context.Background(), b.Hash(), store, nil)
  23         if err != nil {
  24                 t.Fatal(err)
  25         }
  26         err = c1.CommitAppliedBlock(context.Background(), b, state.Empty())
  27         if err != nil {
  28                 testutil.FatalErr(t, err)
  29         }
  30
  31         // Snapshots are applied asynchronously. This loops waits
  32         // until the snapshot is created.
  33         for {
  34                 _, height, _ := store.LatestSnapshot(context.Background())
  35                 if height > 0 {
  36                         break
  37                 }
  38         }
  39
  40         ctx := context.Background()
  41
  42         c2, err := NewChain(context.Background(), b.Hash(), store, nil)
  43         if err != nil {
  44                 t.Fatal(err)
  45         }
  46         block, snapshot, err := c2.Recover(ctx)
  47         if err != nil {
  48                 t.Fatal(err)
  49         }
  50         if block.Height != 1 {
  51                 t.Fatalf("block.Height = %d, want %d", block.Height, 1)
  52         }
  53
  54         err = c2.ValidateBlockForSig(ctx, createEmptyBlock(block, snapshot))
  55         if err != nil {
  56                 t.Fatal(err)
  57         }
  58 }
  59
  60 func createEmptyBlock(block *legacy.Block, snapshot *state.Snapshot) *legacy.Block {
  61         root, err := bc.MerkleRoot(nil)
  62         if err != nil {
  63                 log.Fatalf("calculating empty merkle root: %s", err)
  64         }
  65
  66         return &legacy.Block{
  67                 BlockHeader: legacy.BlockHeader{
  68                         Version:           1,
  69                         Height:            block.Height + 1,
  70                         PreviousBlockHash: block.Hash(),
  71                         TimestampMS:       bc.Millis(time.Now()),
  72                         BlockCommitment: legacy.BlockCommitment{
  73                                 TransactionsMerkleRoot: root,
  74                                 AssetsMerkleRoot:       snapshot.Tree.RootHash(),
  75                                 ConsensusProgram:       block.ConsensusProgram,
  76                         },
  77                 },
  78         }
  79 }