aboutsummaryrefslogtreecommitdiff
path: root/internal/storage/pebble_store_batch_test.go
blob: 06908186b8e9a068a2759928c84075dca088adae (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
package storage

import (
	"github.com/Fuwn/plutia/internal/types"
	"testing"
	"time"
)

func TestPebbleStoreApplyOperationBatch(t *testing.T) {
	tmp := t.TempDir()
	store, err := OpenPebble(tmp)

	if err != nil {
		t.Fatalf("open pebble: %v", err)
	}

	defer store.Close()

	state := types.StateV1{
		Version:      1,
		DID:          "did:plc:test",
		DIDDocument:  []byte(`{"id":"did:plc:test"}`),
		ChainTipHash: "bafy-state-tip",
		LatestOpSeq:  42,
		UpdatedAt:    time.Now().UTC(),
	}
	ref := &types.BlockRefV1{
		Version: 1,
		BlockID: 9,
		Offset:  123,
		Length:  456,
		OpSeq:   42,
		DID:     "did:plc:test",
		CID:     "bafy-op-cid",
		OpHash:  "bafy-op-hash",
	}

	if err := store.ApplyOperationBatch(state, ref, true); err != nil {
		t.Fatalf("apply operation batch: %v", err)
	}

	gotState, ok, err := store.GetState(state.DID)

	if err != nil || !ok {
		t.Fatalf("get state: ok=%v err=%v", ok, err)
	}

	if gotState.ChainTipHash != state.ChainTipHash || gotState.LatestOpSeq != state.LatestOpSeq {
		t.Fatalf("state mismatch: got tip=%s seq=%d", gotState.ChainTipHash, gotState.LatestOpSeq)
	}

	head, ok, err := store.GetChainHead(state.DID)

	if err != nil || !ok || head != state.LatestOpSeq {
		t.Fatalf("chain head mismatch: head=%d ok=%v err=%v", head, ok, err)
	}

	seqs, err := store.ListDIDSequences(state.DID)

	if err != nil {
		t.Fatalf("list did sequences: %v", err)
	}

	if len(seqs) != 1 || seqs[0] != state.LatestOpSeq {
		t.Fatalf("did sequence mismatch: %v", seqs)
	}

	gotRef, ok, err := store.GetOpSeqRef(state.LatestOpSeq)

	if err != nil || !ok {
		t.Fatalf("get opseq ref: ok=%v err=%v", ok, err)
	}

	if gotRef.BlockID != ref.BlockID || gotRef.CID != ref.CID {
		t.Fatalf("op ref mismatch: got block=%d cid=%s", gotRef.BlockID, gotRef.CID)
	}

	globalSeq, err := store.GetGlobalSeq()

	if err != nil || globalSeq != state.LatestOpSeq {
		t.Fatalf("global seq mismatch: seq=%d err=%v", globalSeq, err)
	}
}