/
test_ipld_tree.go
111 lines (105 loc) · 4.01 KB
/
test_ipld_tree.go
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package testutil
import (
"bytes"
"io"
blocks "github.com/ipfs/go-block-format"
"github.com/ipfs/go-cid"
"github.com/ipld/go-ipld-prime"
// to register multicodec
_ "github.com/ipld/go-ipld-prime/codec/dagjson"
"github.com/ipld/go-ipld-prime/fluent"
cidlink "github.com/ipld/go-ipld-prime/linking/cid"
basicnode "github.com/ipld/go-ipld-prime/node/basic"
)
// TestIPLDTree is a set of IPLD Data that forms a tree spread across some blocks
// with a serialized in memory representation
type TestIPLDTree struct {
Storage map[ipld.Link][]byte
LeafAlpha ipld.Node
LeafAlphaLnk ipld.Link
LeafAlphaBlock blocks.Block
LeafBeta ipld.Node
LeafBetaLnk ipld.Link
LeafBetaBlock blocks.Block
MiddleMapNode ipld.Node
MiddleMapNodeLnk ipld.Link
MiddleMapBlock blocks.Block
MiddleListNode ipld.Node
MiddleListNodeLnk ipld.Link
MiddleListBlock blocks.Block
RootNode ipld.Node
RootNodeLnk ipld.Link
RootBlock blocks.Block
}
// NewTestIPLDTree returns a fake tree of nodes, spread across 5 blocks
func NewTestIPLDTree() TestIPLDTree {
var storage = make(map[ipld.Link][]byte)
lsys := cidlink.DefaultLinkSystem()
lsys.StorageWriteOpener = func(ipld.LinkContext) (io.Writer, ipld.BlockWriteCommitter, error) {
buf := bytes.Buffer{}
return &buf, func(lnk ipld.Link) error {
storage[lnk] = buf.Bytes()
return nil
}, nil
}
encode := func(n ipld.Node) (ipld.Node, ipld.Link) {
lp := cidlink.LinkPrototype{Prefix: cid.Prefix{
Version: 1,
Codec: 0x0129,
MhType: 0x13,
MhLength: 4,
}}
lnk, err := lsys.Store(ipld.LinkContext{}, lp, n)
if err != nil {
panic(err)
}
return n, lnk
}
var (
leafAlpha, leafAlphaLnk = encode(basicnode.NewString("alpha"))
leafAlphaBlock, _ = blocks.NewBlockWithCid(storage[leafAlphaLnk], leafAlphaLnk.(cidlink.Link).Cid)
leafBeta, leafBetaLnk = encode(basicnode.NewString("beta"))
leafBetaBlock, _ = blocks.NewBlockWithCid(storage[leafBetaLnk], leafBetaLnk.(cidlink.Link).Cid)
middleMapNode, middleMapNodeLnk = encode(fluent.MustBuildMap(basicnode.Prototype.Map, 3, func(na fluent.MapAssembler) {
na.AssembleEntry("foo").AssignBool(true)
na.AssembleEntry("bar").AssignBool(false)
na.AssembleEntry("nested").CreateMap(2, func(na fluent.MapAssembler) {
na.AssembleEntry("alink").AssignLink(leafAlphaLnk)
na.AssembleEntry("nonlink").AssignString("zoo")
})
}))
middleMapBlock, _ = blocks.NewBlockWithCid(storage[middleMapNodeLnk], middleMapNodeLnk.(cidlink.Link).Cid)
middleListNode, middleListNodeLnk = encode(fluent.MustBuildList(basicnode.Prototype.List, 4, func(na fluent.ListAssembler) {
na.AssembleValue().AssignLink(leafAlphaLnk)
na.AssembleValue().AssignLink(leafAlphaLnk)
na.AssembleValue().AssignLink(leafBetaLnk)
na.AssembleValue().AssignLink(leafAlphaLnk)
}))
middleListBlock, _ = blocks.NewBlockWithCid(storage[middleListNodeLnk], middleListNodeLnk.(cidlink.Link).Cid)
rootNode, rootNodeLnk = encode(fluent.MustBuildMap(basicnode.Prototype.Map, 4, func(na fluent.MapAssembler) {
na.AssembleEntry("plain").AssignString("olde string")
na.AssembleEntry("linkedString").AssignLink(leafAlphaLnk)
na.AssembleEntry("linkedMap").AssignLink(middleMapNodeLnk)
na.AssembleEntry("linkedList").AssignLink(middleListNodeLnk)
}))
rootBlock, _ = blocks.NewBlockWithCid(storage[rootNodeLnk], rootNodeLnk.(cidlink.Link).Cid)
)
return TestIPLDTree{
Storage: storage,
LeafAlpha: leafAlpha,
LeafAlphaLnk: leafAlphaLnk,
LeafAlphaBlock: leafAlphaBlock,
LeafBeta: leafBeta,
LeafBetaLnk: leafBetaLnk,
LeafBetaBlock: leafBetaBlock,
MiddleMapNode: middleMapNode,
MiddleMapNodeLnk: middleMapNodeLnk,
MiddleMapBlock: middleMapBlock,
MiddleListNode: middleListNode,
MiddleListNodeLnk: middleListNodeLnk,
MiddleListBlock: middleListBlock,
RootNode: rootNode,
RootNodeLnk: rootNodeLnk,
RootBlock: rootBlock,
}
}