github.com/storacha/go-ucanto@v0.7.2/core/schema/link_test.go (about)

     1  package schema_test
     2  
     3  import (
     4  	"fmt"
     5  	"iter"
     6  	"maps"
     7  	"regexp"
     8  	"testing"
     9  
    10  	"github.com/ipfs/go-cid"
    11  	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
    12  	basicnode "github.com/ipld/go-ipld-prime/node/basic"
    13  	"github.com/multiformats/go-base32"
    14  	mh "github.com/multiformats/go-multihash"
    15  	"github.com/storacha/go-ucanto/core/iterable"
    16  	"github.com/storacha/go-ucanto/core/schema"
    17  	"github.com/storacha/go-ucanto/testing/helpers"
    18  	"github.com/stretchr/testify/require"
    19  )
    20  
    21  func NewSet[T comparable](list iter.Seq[T]) iter.Seq[T] {
    22  	set := make(map[T]struct{})
    23  	for elem := range list {
    24  		set[elem] = struct{}{}
    25  	}
    26  	return maps.Keys(set)
    27  }
    28  func TestReadLink(t *testing.T) {
    29  	fixtures := map[string]cid.Cid{
    30  		"pb":          cid.MustParse("QmTgnQBKj7eTV7ohraBCmh1DLwerUd2X9Rxzgf3gyMJbC8"),
    31  		"cbor":        cid.MustParse("bafyreieuo63r3y2nuycaq4b3q2xvco3nprlxiwzcfp4cuupgaywat3z6mq"),
    32  		"rawIdentity": cid.MustParse("bafkqaaa"),
    33  		"ipns":        cid.MustParse("k2k4r8kuj2bs2l996lhjx8rc727xlvthtak8o6eia3qm5adxvs5k84gf"),
    34  		"sha512":      cid.MustParse("kgbuwaen1jrbjip6iwe9mqg54spvuucyz7f5jho2tkc2o0c7xzqwpxtogbyrwck57s9is6zqlwt9rsxbuvszym10nbaxt9jn7sf4eksqd"),
    35  	}
    36  
    37  	links := maps.Values(fixtures)
    38  	versions := NewSet(iterable.Map(func(c cid.Cid) uint64 { return c.Version() }, maps.Values(fixtures)))
    39  	codecs := NewSet(iterable.Map(func(c cid.Cid) uint64 { return c.Prefix().Codec }, maps.Values(fixtures)))
    40  	algs := NewSet(iterable.Map(func(c cid.Cid) uint64 { return c.Prefix().MhType }, maps.Values(fixtures)))
    41  	digests := NewSet(iterable.Map(func(c cid.Cid) string {
    42  		h := c.Hash()
    43  		dh := helpers.Must(mh.Decode(h))
    44  		return string(dh.Digest)
    45  	}, maps.Values(fixtures)))
    46  
    47  	for link := range links {
    48  		t.Run(fmt.Sprintf("%s ➡ schema.Link()", link), func(t *testing.T) {
    49  			output, err := schema.Link().Read(basicnode.NewLink(cidlink.Link{Cid: link}))
    50  			require.NoError(t, err)
    51  			require.Equal(t, output, cidlink.Link{Cid: link}, link.String())
    52  		})
    53  
    54  		for version := range versions {
    55  			t.Run(fmt.Sprintf("%s ➡ schema.Link(WithVersion(%d))", link, version), func(t *testing.T) {
    56  				reader := schema.Link(schema.WithVersion(version))
    57  				output, err := reader.Read(basicnode.NewLink(cidlink.Link{Cid: link}))
    58  				if link.Version() == version {
    59  					require.NoError(t, err)
    60  					require.Equal(t, output, cidlink.Link{Cid: link})
    61  				} else {
    62  					require.Error(t, err)
    63  					require.Contains(t, err.Error(), "Expected link to be CID version")
    64  				}
    65  			})
    66  		}
    67  
    68  		for codec := range codecs {
    69  			t.Run(fmt.Sprintf("%s ➡ schema.Link(WithCodec(%d))", link, codec), func(t *testing.T) {
    70  				reader := schema.Link(schema.WithCodec(codec))
    71  				output, err := reader.Read(basicnode.NewLink(cidlink.Link{Cid: link}))
    72  				if link.Prefix().Codec == codec {
    73  					require.NoError(t, err)
    74  					require.Equal(t, output, cidlink.Link{Cid: link})
    75  				} else {
    76  					require.Error(t, err)
    77  					require.Regexp(t, helpers.Must(regexp.Compile("Expected link to be CID with .* code")), err.Error())
    78  				}
    79  			})
    80  		}
    81  
    82  		for alg := range algs {
    83  			t.Run(fmt.Sprintf("%s ➡ schema.Link(WithMultihashConfig(WithAlg(%d)))", link, alg), func(t *testing.T) {
    84  				reader := schema.Link(schema.WithMultihashConfig(schema.WithAlg(alg)))
    85  				output, err := reader.Read(basicnode.NewLink(cidlink.Link{Cid: link}))
    86  				if link.Prefix().MhType == alg {
    87  					require.NoError(t, err)
    88  					require.Equal(t, output, cidlink.Link{Cid: link})
    89  				} else {
    90  					require.Error(t, err)
    91  					require.Regexp(t, helpers.Must(regexp.Compile("Expected link to be CID with .* hashing algorithm")), err.Error())
    92  				}
    93  			})
    94  		}
    95  
    96  		for digest := range digests {
    97  			t.Run(fmt.Sprintf("%s ➡ schema.Link(WithMultihashConfig(WithDigest(%s)))", link, base32.StdEncoding.EncodeToString([]byte(digest))), func(t *testing.T) {
    98  				reader := schema.Link(schema.WithMultihashConfig(schema.WithDigest([]byte(digest))))
    99  				output, err := reader.Read(basicnode.NewLink(cidlink.Link{Cid: link}))
   100  				if string(helpers.Must(mh.Decode(link.Hash())).Digest) == digest {
   101  					require.NoError(t, err)
   102  					require.Equal(t, output, cidlink.Link{Cid: link})
   103  				} else {
   104  					require.Error(t, err)
   105  					require.Regexp(t, helpers.Must(regexp.Compile("Expected link with .* hash digest")), err.Error())
   106  				}
   107  			})
   108  		}
   109  	}
   110  }