chore: version 0.4.0

cid.go

@@ -456,7 +456,7 @@ func (c Cid) Equals(o Cid) bool {
 // UnmarshalJSON parses the JSON representation of a Cid.
 func (c *Cid) UnmarshalJSON(b []byte) error {
 	if len(b) < 2 {
-		return fmt.Errorf("invalid cid json blob")
+		return ErrInvalidCid{fmt.Errorf("invalid cid json blob")}
 	}
 	obj := struct {
 		CidTarget string `json:"/"`
@@ -464,7 +464,7 @@ func (c *Cid) UnmarshalJSON(b []byte) error {
 	objptr := &obj
 	err := json.Unmarshal(b, &objptr)
 	if err != nil {
-		return err
+		return ErrInvalidCid{err}
 	}
 	if objptr == nil {
 		*c = Cid{}
@@ -472,12 +472,12 @@ func (c *Cid) UnmarshalJSON(b []byte) error {
 	}
 
 	if obj.CidTarget == "" {
-		return fmt.Errorf("cid was incorrectly formatted")
+		return ErrInvalidCid{fmt.Errorf("cid was incorrectly formatted")}
 	}
 
 	out, err := Decode(obj.CidTarget)
 	if err != nil {
-		return err
+		return ErrInvalidCid{err}
 	}
 
 	*c = out
@@ -564,12 +564,12 @@ func (p Prefix) Sum(data []byte) (Cid, error) {
 	if p.Version == 0 && (p.MhType != mh.SHA2_256 ||
 		(p.MhLength != 32 && p.MhLength != -1)) {
 
-		return Undef, fmt.Errorf("invalid v0 prefix")
+		return Undef, ErrInvalidCid{fmt.Errorf("invalid v0 prefix")}
 	}
 
 	hash, err := mh.Sum(data, p.MhType, length)
 	if err != nil {
-		return Undef, err
+		return Undef, ErrInvalidCid{err}
 	}
 
 	switch p.Version {
@@ -578,7 +578,7 @@ func (p Prefix) Sum(data []byte) (Cid, error) {
 	case 1:
 		return NewCidV1(p.Codec, hash), nil
 	default:
-		return Undef, fmt.Errorf("invalid cid version")
+		return Undef, ErrInvalidCid{fmt.Errorf("invalid cid version")}
 	}
 }
 
@@ -608,22 +608,22 @@ func PrefixFromBytes(buf []byte) (Prefix, error) {
 	r := bytes.NewReader(buf)
 	vers, err := varint.ReadUvarint(r)
 	if err != nil {
-		return Prefix{}, err
+		return Prefix{}, ErrInvalidCid{err}
 	}
 
 	codec, err := varint.ReadUvarint(r)
 	if err != nil {
-		return Prefix{}, err
+		return Prefix{}, ErrInvalidCid{err}
 	}
 
 	mhtype, err := varint.ReadUvarint(r)
 	if err != nil {
-		return Prefix{}, err
+		return Prefix{}, ErrInvalidCid{err}
 	}
 
 	mhlen, err := varint.ReadUvarint(r)
 	if err != nil {
-		return Prefix{}, err
+		return Prefix{}, ErrInvalidCid{err}
 	}
 
 	return Prefix{

cid_test.go

@@ -163,6 +163,9 @@ func TestBasesMarshaling(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected too-short error from ExtractEncoding")
 	}
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
+	}
 	if ee != -1 {
 		t.Fatal("expected -1 from too-short ExtractEncoding")
 	}
@@ -379,6 +382,9 @@ func TestInvalidV0Prefix(t *testing.T) {
 		if err == nil {
 			t.Fatalf("should error (index %d)", i)
 		}
+		if !errors.Is(err, ErrInvalidCid{}) {
+			t.Fatal("expected error to be ErrInvalidCid")
+		}
 	}
 }
 
@@ -388,6 +394,9 @@ func TestBadPrefix(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected error on v3 prefix Sum")
 	}
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
+	}
 }
 
 func TestPrefixRoundtrip(t *testing.T) {
@@ -424,18 +433,30 @@ func TestBadPrefixFromBytes(t *testing.T) {
 	if err == nil {
 		t.Fatal("expected error for bad byte 0")
 	}
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
+	}
 	_, err = PrefixFromBytes([]byte{0x01, 0x80})
 	if err == nil {
 		t.Fatal("expected error for bad byte 1")
 	}
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
+	}
 	_, err = PrefixFromBytes([]byte{0x01, 0x01, 0x80})
 	if err == nil {
 		t.Fatal("expected error for bad byte 2")
 	}
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
+	}
 	_, err = PrefixFromBytes([]byte{0x01, 0x01, 0x01, 0x80})
 	if err == nil {
 		t.Fatal("expected error for bad byte 3")
 	}
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
+	}
 }
 
 func Test16BytesVarint(t *testing.T) {
@@ -582,17 +603,29 @@ func TestJsonRoundTrip(t *testing.T) {
 		t.Fatal("cids not equal for Cid")
 	}
 
-	if err = actual2.UnmarshalJSON([]byte("1")); err == nil {
+	err = actual2.UnmarshalJSON([]byte("1"))
+	if err == nil {
 		t.Fatal("expected error for too-short JSON")
 	}
-
-	if err = actual2.UnmarshalJSON([]byte(`{"nope":"nope"}`)); err == nil {
-		t.Fatal("expected error for bad CID JSON")
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
 	}
 
-	if err = actual2.UnmarshalJSON([]byte(`bad "" json!`)); err == nil {
+	err = actual2.UnmarshalJSON([]byte(`{"nope":"nope"}`))
+	if err == nil {
+		t.Fatal("expected error for bad CID JSON")
+	}
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
+	}
+
+	err = actual2.UnmarshalJSON([]byte(`bad "" json!`))
+	if err == nil {
 		t.Fatal("expected error for bad JSON")
 	}
+	if !errors.Is(err, ErrInvalidCid{}) {
+		t.Fatal("expected error to be ErrInvalidCid")
+	}
 
 	var actual3 Cid
 	enc, err = actual3.MarshalJSON()
@@ -777,14 +810,79 @@ func TestLoggable(t *testing.T) {
 	}
 }
 
-func TestErrInvalidCid(t *testing.T) {
-	_, err := Decode("not-a-cid")
-	if err == nil {
-		t.Fatal("expected error")
-	}
-
-	is := errors.Is(err, ErrInvalidCid{})
-	if !is {
-		t.Fatal("expected error to be ErrInvalidCid")
+func TestErrInvalidCidIs(t *testing.T) {
+	for i, test := range []struct {
+		err    error
+		target error
+	}{
+		{&ErrInvalidCid{}, ErrInvalidCid{}},
+		{ErrInvalidCid{}, &ErrInvalidCid{}},
+		{ErrInvalidCid{}, ErrInvalidCid{}},
+		{&ErrInvalidCid{}, &ErrInvalidCid{}},
+	} {
+		if !errors.Is(test.err, test.target) {
+			t.Fatalf("expected error to be ErrInvalidCid, case %d", i)
+		}
 	}
 }
+
+func TestErrInvalidCid(t *testing.T) {
+	run := func(err error) {
+		if err == nil {
+			t.Fatal("expected error")
+		}
+
+		if !strings.HasPrefix(err.Error(), "invalid cid: ") {
+			t.Fatal(`expected error message to contain "invalid cid: "`)
+		}
+
+		is := errors.Is(err, ErrInvalidCid{})
+		if !is {
+			t.Fatal("expected error to be ErrInvalidCid")
+		}
+
+		if !errors.Is(err, &ErrInvalidCid{}) {
+			t.Fatal("expected error to be &ErrInvalidCid")
+		}
+	}
+
+	_, err := Decode("")
+	run(err)
+
+	_, err = Decode("not-a-cid")
+	run(err)
+
+	_, err = Decode("bafyInvalid")
+	run(err)
+
+	_, err = Decode("QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zIII")
+	run(err)
+
+	_, err = Cast([]byte("invalid"))
+	run(err)
+
+	_, err = Parse("not-a-cid")
+	run(err)
+
+	_, err = Parse("bafyInvalid")
+	run(err)
+
+	_, err = Parse("QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zIII")
+	run(err)
+
+	_, err = Parse(123)
+	run(err)
+
+	_, _, err = CidFromBytes([]byte("invalid"))
+	run(err)
+
+	_, err = Prefix{}.Sum([]byte("data"))
+	run(err)
+
+	_, err = PrefixFromBytes([]byte{0x80})
+	run(err)
+
+	_, err = ExtractEncoding("invalid ")
+	run(err)
+
+}

version.json

@@ -1,3 +1,3 @@
 {
-  "version": "v0.3.2"
+  "version": "v0.4.0"
 }