test: add tests for most functions

Author: hacdias

gateway/blocks_backend.go

@@ -259,13 +259,12 @@ func (bb *BlocksBackend) GetCAR(ctx context.Context, p path.ImmutablePath, param
 		// Setup the UnixFS resolver.
 		f := newNodeGetterFetcherSingleUseFactory(ctx, blockGetter)
 		pathResolver := resolver.NewBasicResolver(f)
-		ip := ipfspath.FromString(p.String())
-		_, _, err = pathResolver.ResolveToLastNode(ctx, ip)
+		_, _, err = pathResolver.ResolveToLastNode(ctx, p)
 
 		if isErrNotFound(err) {
 			return ContentPathMetadata{
 				PathSegmentRoots: nil,
-				LastSegment:      ifacepath.NewResolvedPath(ip, rootCid, rootCid, ""),
+				LastSegment:      path.NewIPFSPath(rootCid),
 				ContentType:      "",
 			}, io.NopCloser(&buf), nil
 		}

gateway/gateway_test.go

@@ -58,10 +58,10 @@ func TestGatewayGet(t *testing.T) {
 		text   string
 	}{
 		{"127.0.0.1:8080", "/", http.StatusNotFound, "404 page not found\n"},
-		{"127.0.0.1:8080", "/ipfs", http.StatusBadRequest, "invalid path \"/ipfs/\": not enough path components\n"},
-		{"127.0.0.1:8080", "/ipns", http.StatusBadRequest, "invalid path \"/ipns/\": not enough path components\n"},
+		{"127.0.0.1:8080", "/ipfs", http.StatusBadRequest, "invalid path \"/ipfs/\": path does not have enough components\n"},
+		{"127.0.0.1:8080", "/ipns", http.StatusBadRequest, "invalid path \"/ipns/\": path does not have enough components\n"},
 		{"127.0.0.1:8080", "/" + k.Cid().String(), http.StatusNotFound, "404 page not found\n"},
-		{"127.0.0.1:8080", "/ipfs/this-is-not-a-cid", http.StatusBadRequest, "invalid path \"/ipfs/this-is-not-a-cid\": invalid CID: invalid cid: illegal base32 data at input byte 3\n"},
+		{"127.0.0.1:8080", "/ipfs/this-is-not-a-cid", http.StatusBadRequest, "invalid path \"/ipfs/this-is-not-a-cid\": invalid cid: illegal base32 data at input byte 3\n"},
 		{"127.0.0.1:8080", k.String(), http.StatusOK, "fnord"},
 		{"127.0.0.1:8080", "/ipns/nxdomain.example.com", http.StatusInternalServerError, "failed to resolve /ipns/nxdomain.example.com: " + namesys.ErrResolveFailed.Error() + "\n"},
 		{"127.0.0.1:8080", "/ipns/%0D%0A%0D%0Ahello", http.StatusInternalServerError, "failed to resolve /ipns/\\r\\n\\r\\nhello: " + namesys.ErrResolveFailed.Error() + "\n"},

path/error.go

@@ -1,20 +1,27 @@
 package path
 
 import (
+	"errors"
 	"fmt"
 )
 
+var (
+	ErrExpectedImmutable      = errors.New("path was expected to be immutable")
+	ErrInsufficientComponents = errors.New("path does not have enough components")
+	ErrUnknownNamespace       = errors.New("unknown namespace")
+)
+
 type ErrInvalidPath struct {
-	error error
-	path  string
+	err  error
+	path string
 }
 
 func (e ErrInvalidPath) Error() string {
-	return fmt.Sprintf("invalid path %q: %s", e.path, e.error)
+	return fmt.Sprintf("invalid path %q: %s", e.path, e.err)
 }
 
 func (e ErrInvalidPath) Unwrap() error {
-	return e.error
+	return e.err
 }
 
 func (e ErrInvalidPath) Is(err error) bool {

path/error_test.go

@@ -6,11 +6,11 @@ import (
 )
 
 func TestErrorIs(t *testing.T) {
-	if !errors.Is(ErrInvalidPath{path: "foo", error: errors.New("bar")}, ErrInvalidPath{}) {
+	if !errors.Is(ErrInvalidPath{path: "foo", err: errors.New("bar")}, ErrInvalidPath{}) {
 		t.Fatal("error must be error")
 	}
 
-	if !errors.Is(&ErrInvalidPath{path: "foo", error: errors.New("bar")}, ErrInvalidPath{}) {
+	if !errors.Is(&ErrInvalidPath{path: "foo", err: errors.New("bar")}, ErrInvalidPath{}) {
 		t.Fatal("pointer to error must be error")
 	}
 }

path/path.go

@@ -111,13 +111,13 @@ type immutablePath struct {
 
 func NewImmutablePath(p Path) (ImmutablePath, error) {
 	if p.Namespace().Mutable() {
-		return nil, fmt.Errorf("path was expected to be immutable: %s", p.String())
+		return nil, ErrInvalidPath{err: ErrExpectedImmutable, path: p.String()}
 	}
 
 	segments := p.Segments()
 	cid, err := cid.Decode(segments[1])
 	if err != nil {
-		return nil, &ErrInvalidPath{error: fmt.Errorf("invalid CID: %w", err), path: p.String()}
+		return nil, &ErrInvalidPath{err: err, path: p.String()}
 	}
 
 	return immutablePath{path: p, cid: cid}, nil
@@ -149,7 +149,7 @@ func (ip immutablePath) Remainder() string {
 
 // NewIPFSPath returns a new "/ipfs" path with the provided CID.
 func NewIPFSPath(cid cid.Cid) ImmutablePath {
-	return &immutablePath{
+	return immutablePath{
 		path: path{
 			str:       fmt.Sprintf("/%s/%s", IPFSNamespace, cid.String()),
 			namespace: IPFSNamespace,
@@ -160,7 +160,7 @@ func NewIPFSPath(cid cid.Cid) ImmutablePath {
 
 // NewIPLDPath returns a new "/ipld" path with the provided CID.
 func NewIPLDPath(cid cid.Cid) ImmutablePath {
-	return &immutablePath{
+	return immutablePath{
 		path: path{
 			str:       fmt.Sprintf("/%s/%s", IPLDNamespace, cid.String()),
 			namespace: IPLDNamespace,
@@ -169,10 +169,10 @@ func NewIPLDPath(cid cid.Cid) ImmutablePath {
 	}
 }
 
-// NewPath takes the given string and returns a well-forme and sanitized [Path].
+// NewPath takes the given string and returns a well-formed and sanitized [Path].
 // The given string is cleaned through [gopath.Clean], but preserving the final
 // trailing slash. This function returns an error when the given string is not
-// a valid path.
+// a valid content path.
 func NewPath(str string) (Path, error) {
 	cleaned := gopath.Clean(str)
 	components := strings.Split(cleaned, "/")
@@ -186,18 +186,18 @@ func NewPath(str string) (Path, error) {
 	// components: [" " "{namespace}" "{element}"]. The first component must therefore
 	// be empty.
 	if len(components) < 3 || components[0] != "" {
-		return nil, &ErrInvalidPath{error: fmt.Errorf("not enough path components"), path: str}
+		return nil, &ErrInvalidPath{err: ErrInsufficientComponents, path: str}
 	}
 
 	switch components[1] {
 	case "ipfs", "ipld":
 		if components[2] == "" {
-			return nil, &ErrInvalidPath{error: fmt.Errorf("not enough path components"), path: str}
+			return nil, &ErrInvalidPath{err: ErrInsufficientComponents, path: str}
 		}
 
 		cid, err := cid.Decode(components[2])
 		if err != nil {
-			return nil, &ErrInvalidPath{error: fmt.Errorf("invalid CID: %w", err), path: str}
+			return nil, &ErrInvalidPath{err: err, path: str}
 		}
 
 		ns := IPFSNamespace
@@ -214,15 +214,15 @@ func NewPath(str string) (Path, error) {
 		}, nil
 	case "ipns":
 		if components[2] == "" {
-			return nil, &ErrInvalidPath{error: fmt.Errorf("not enough path components"), path: str}
+			return nil, &ErrInvalidPath{err: ErrInsufficientComponents, path: str}
 		}
 
 		return path{
 			str:       cleaned,
 			namespace: IPNSNamespace,
 		}, nil
 	default:
-		return nil, &ErrInvalidPath{error: fmt.Errorf("unknown namespace %q", components[1]), path: str}
+		return nil, &ErrInvalidPath{err: fmt.Errorf("%w: %q", ErrUnknownNamespace, components[1]), path: str}
 	}
 }