Merge branch 'serial-tests'

encoding/dagcbor/roundtripCidlink_test.go

+package dagcbor
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"testing"
+
+	. "github.com/warpfork/go-wish"
+
+	cid "github.com/ipfs/go-cid"
+	ipld "github.com/ipld/go-ipld-prime"
+	ipldfree "github.com/ipld/go-ipld-prime/impl/free"
+	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
+)
+
+func TestRoundtripCidlink(t *testing.T) {
+	lb := cidlink.LinkBuilder{cid.Prefix{
+		Version:  1,
+		Codec:    0x71,
+		MhType:   0x17,
+		MhLength: 4,
+	}}
+	buf := bytes.Buffer{}
+	lnk, err := lb.Build(context.Background(), ipld.LinkContext{}, n,
+		func(ipld.LinkContext) (io.Writer, ipld.StoreCommitter, error) {
+			return &buf, func(lnk ipld.Link) error { return nil }, nil
+		},
+	)
+	Wish(t, err, ShouldEqual, nil)
+	n2, err := lnk.Load(context.Background(), ipld.LinkContext{}, ipldfree.NodeBuilder(),
+		func(lnk ipld.Link, _ ipld.LinkContext) (io.Reader, error) {
+			return bytes.NewBuffer(buf.Bytes()), nil
+		},
+	)
+	Wish(t, err, ShouldEqual, nil)
+	Wish(t, n2, ShouldEqual, n)
+}

encoding/dagcbor/roundtrip_test.go

+package dagcbor
+
+import (
+	"bytes"
+	"testing"
+
+	. "github.com/warpfork/go-wish"
+
+	"github.com/ipld/go-ipld-prime/fluent"
+	ipldfree "github.com/ipld/go-ipld-prime/impl/free"
+)
+
+var fnb = fluent.WrapNodeBuilder(ipldfree.NodeBuilder())
+var n = fnb.CreateMap(func(mb fluent.MapBuilder, knb fluent.NodeBuilder, vnb fluent.NodeBuilder) {
+	mb.Insert(knb.CreateString("plain"), vnb.CreateString("olde string"))
+	mb.Insert(knb.CreateString("map"), vnb.CreateMap(func(mb fluent.MapBuilder, knb fluent.NodeBuilder, vnb fluent.NodeBuilder) {
+		mb.Insert(knb.CreateString("one"), vnb.CreateInt(1))
+		mb.Insert(knb.CreateString("two"), vnb.CreateInt(2))
+	}))
+	mb.Insert(knb.CreateString("list"), fnb.CreateList(func(lb fluent.ListBuilder, vnb fluent.NodeBuilder) {
+		lb.Append(vnb.CreateString("three"))
+		lb.Append(vnb.CreateString("four"))
+	}))
+	mb.Insert(knb.CreateString("nested"), vnb.CreateMap(func(mb fluent.MapBuilder, knb fluent.NodeBuilder, vnb fluent.NodeBuilder) {
+		mb.Insert(knb.CreateString("deeper"), fnb.CreateList(func(lb fluent.ListBuilder, vnb fluent.NodeBuilder) {
+			lb.Append(vnb.CreateString("things"))
+		}))
+	}))
+})
+var serial = "\xa4eplainkolde stringcmap\xa2cone\x01ctwo\x02dlist\x82ethreedfourfnested\xa1fdeeper\x81fthings"
+
+func TestRoundtrip(t *testing.T) {
+	t.Run("encoding", func(t *testing.T) {
+		var buf bytes.Buffer
+		err := Encoder(n, &buf)
+		Wish(t, err, ShouldEqual, nil)
+		Wish(t, buf.String(), ShouldEqual, serial)
+	})
+	t.Run("decoding", func(t *testing.T) {
+		buf := bytes.NewBufferString(serial)
+		n2, err := Decoder(ipldfree.NodeBuilder(), buf)
+		Wish(t, err, ShouldEqual, nil)
+		Wish(t, n2, ShouldEqual, n)
+	})
+}

encoding/dagcbor/unmarshal.go

@@ -43,10 +43,7 @@ func unmarshal(nb ipld.NodeBuilder, tokSrc shared.TokenSource, tk *tok.Token) (i
 		var k string
 		var v ipld.Node
 		for {
-			done, err := tokSrc.Step(tk)
-			if done {
-				return nil, fmt.Errorf("unexpected EOF")
-			}
+			_, err := tokSrc.Step(tk)
 			if err != nil {
 				return nil, err
 			}
@@ -92,10 +89,7 @@ func unmarshal(nb ipld.NodeBuilder, tokSrc shared.TokenSource, tk *tok.Token) (i
 		}
 		observedLen := 0
 		for {
-			done, err := tokSrc.Step(tk)
-			if done {
-				return nil, fmt.Errorf("unexpected EOF")
-			}
+			_, err := tokSrc.Step(tk)
 			if err != nil {
 				return nil, err
 			}

encoding/dagjson/multicodec.go

 package dagjson
 
 import (
+	"fmt"
 	"io"
 
 	"github.com/polydawn/refmt/json"
@@ -22,7 +23,33 @@ func init() {
 func Decoder(nb ipld.NodeBuilder, r io.Reader) (ipld.Node, error) {
 	// Shell out directly to generic builder path.
 	//  (There's not really any fastpaths of note for json.)
-	return Unmarshal(nb, json.NewDecoder(r))
+	n, err := Unmarshal(nb, json.NewDecoder(r))
+	if err != nil {
+		return n, err
+	}
+	// Slurp any remaining whitespace.
+	//  (This is relevant if our reader is tee'ing bytes to a hasher, and
+	//   the json contained any trailing whitespace.)
+	//  (We can't actually support multiple objects per reader from here;
+	//   we can't unpeek if we find a non-whitespace token, so our only
+	//    option is to error if this reader seems to contain more content.)
+	var buf [1]byte
+	for {
+		_, err := r.Read(buf[:])
+		switch buf[0] {
+		case ' ', '\t', '\r', '\n': // continue
+		default:
+			return n, fmt.Errorf("unexpected content after end of json object")
+		}
+		if err == nil {
+			continue
+		} else if err == io.EOF {
+			return n, nil
+		} else {
+			return n, err
+		}
+	}
+	return n, err
 }
 
 func Encoder(n ipld.Node, w io.Writer) error {

encoding/dagjson/roundtripCidlink_test.go

+package dagjson
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"testing"
+
+	. "github.com/warpfork/go-wish"
+
+	cid "github.com/ipfs/go-cid"
+	ipld "github.com/ipld/go-ipld-prime"
+	ipldfree "github.com/ipld/go-ipld-prime/impl/free"
+	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
+)
+
+func TestRoundtripCidlink(t *testing.T) {
+	lb := cidlink.LinkBuilder{cid.Prefix{
+		Version:  1,
+		Codec:    0x0129,
+		MhType:   0x17,
+		MhLength: 4,
+	}}
+	buf := bytes.Buffer{}
+	lnk, err := lb.Build(context.Background(), ipld.LinkContext{}, n,
+		func(ipld.LinkContext) (io.Writer, ipld.StoreCommitter, error) {
+			return &buf, func(lnk ipld.Link) error { return nil }, nil
+		},
+	)
+	Wish(t, err, ShouldEqual, nil)
+	n2, err := lnk.Load(context.Background(), ipld.LinkContext{}, ipldfree.NodeBuilder(),
+		func(lnk ipld.Link, _ ipld.LinkContext) (io.Reader, error) {
+			return bytes.NewBuffer(buf.Bytes()), nil
+		},
+	)
+	Wish(t, err, ShouldEqual, nil)
+	Wish(t, n2, ShouldEqual, n)
+}

encoding/dagjson/roundtrip_test.go

+package dagjson
+
+import (
+	"bytes"
+	"testing"
+
+	. "github.com/warpfork/go-wish"
+
+	"github.com/ipld/go-ipld-prime/fluent"
+	ipldfree "github.com/ipld/go-ipld-prime/impl/free"
+)
+
+var fnb = fluent.WrapNodeBuilder(ipldfree.NodeBuilder())
+var n = fnb.CreateMap(func(mb fluent.MapBuilder, knb fluent.NodeBuilder, vnb fluent.NodeBuilder) {
+	mb.Insert(knb.CreateString("plain"), vnb.CreateString("olde string"))
+	mb.Insert(knb.CreateString("map"), vnb.CreateMap(func(mb fluent.MapBuilder, knb fluent.NodeBuilder, vnb fluent.NodeBuilder) {
+		mb.Insert(knb.CreateString("one"), vnb.CreateInt(1))
+		mb.Insert(knb.CreateString("two"), vnb.CreateInt(2))
+	}))
+	mb.Insert(knb.CreateString("list"), fnb.CreateList(func(lb fluent.ListBuilder, vnb fluent.NodeBuilder) {
+		lb.Append(vnb.CreateString("three"))
+		lb.Append(vnb.CreateString("four"))
+	}))
+	mb.Insert(knb.CreateString("nested"), vnb.CreateMap(func(mb fluent.MapBuilder, knb fluent.NodeBuilder, vnb fluent.NodeBuilder) {
+		mb.Insert(knb.CreateString("deeper"), fnb.CreateList(func(lb fluent.ListBuilder, vnb fluent.NodeBuilder) {
+			lb.Append(vnb.CreateString("things"))
+		}))
+	}))
+})
+var serial = `{
+	"plain": "olde string",
+	"map": {
+		"one": 1,
+		"two": 2
+	},
+	"list": [
+		"three",
+		"four"
+	],
+	"nested": {
+		"deeper": [
+			"things"
+		]
+	}
+}
+`
+
+func TestRoundtrip(t *testing.T) {
+	t.Run("encoding", func(t *testing.T) {
+		var buf bytes.Buffer
+		err := Encoder(n, &buf)
+		Wish(t, err, ShouldEqual, nil)
+		Wish(t, buf.String(), ShouldEqual, serial)
+	})
+	t.Run("decoding", func(t *testing.T) {
+		buf := bytes.NewBufferString(serial)
+		n2, err := Decoder(ipldfree.NodeBuilder(), buf)
+		Wish(t, err, ShouldEqual, nil)
+		Wish(t, n2, ShouldEqual, n)
+	})
+}

encoding/dagjson/unmarshal.go

@@ -43,10 +43,7 @@ func unmarshal(nb ipld.NodeBuilder, tokSrc shared.TokenSource, tk *tok.Token) (i
 		var k string
 		var v ipld.Node
 		for {
-			done, err := tokSrc.Step(tk)
-			if done {
-				return nil, fmt.Errorf("unexpected EOF")
-			}
+			_, err := tokSrc.Step(tk)
 			if err != nil {
 				return nil, err
 			}
@@ -104,10 +101,7 @@ func unmarshal(nb ipld.NodeBuilder, tokSrc shared.TokenSource, tk *tok.Token) (i
 		}
 		observedLen := 0
 		for {
-			done, err := tokSrc.Step(tk)
-			if done {
-				return nil, fmt.Errorf("unexpected EOF")
-			}
+			_, err := tokSrc.Step(tk)
 			if err != nil {
 				return nil, err
 			}

encoding/unmarshal.go

@@ -54,10 +54,7 @@ func unmarshal(nb ipld.NodeBuilder, tokSrc shared.TokenSource, tk *tok.Token) (i
 		var k string
 		var v ipld.Node
 		for {
-			done, err := tokSrc.Step(tk)
-			if done {
-				return nil, fmt.Errorf("unexpected EOF")
-			}
+			_, err := tokSrc.Step(tk)
 			if err != nil {
 				return nil, err
 			}
@@ -103,10 +100,7 @@ func unmarshal(nb ipld.NodeBuilder, tokSrc shared.TokenSource, tk *tok.Token) (i
 		}
 		observedLen := 0
 		for {
-			done, err := tokSrc.Step(tk)
-			if done {
-				return nil, fmt.Errorf("unexpected EOF")
-			}
+			_, err := tokSrc.Step(tk)
 			if err != nil {
 				return nil, err
 			}

linking/cid/cidLink.go

@@ -8,7 +8,6 @@ import (
 
 	cid "github.com/ipfs/go-cid"
 	ipld "github.com/ipld/go-ipld-prime"
-	multihash "github.com/multiformats/go-multihash"
 )
 
 var (
@@ -44,12 +43,12 @@ func (lnk Link) Load(ctx context.Context, lnkCtx ipld.LinkContext, nb ipld.NodeB
 			return nil, err
 		}
 	}
-	hash, err := multihash.Sum(hasher.Bytes(), lnk.Prefix().MhType, lnk.Prefix().MhLength)
+	cid, err := lnk.Prefix().Sum(hasher.Bytes())
 	if err != nil {
 		return nil, err
 	}
-	if hash.B58String() != lnk.Hash().B58String() {
-		return nil, fmt.Errorf("hash mismatch!")
+	if cid != lnk.Cid {
+		return nil, fmt.Errorf("hash mismatch!  %q (actual) != %q (expected)", cid, lnk.Cid)
 	}
 	if decodeErr != nil {
 		return nil, decodeErr