feat: add CID
This commit is contained in:
parent
38044bf297
commit
aa48eb8ac4
GPG Key ID:
C997C339BE476FF2
|
|
@ -0,0 +1,230 @@
|
|||
package cid
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"fmt"
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/cid/multibase"
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/internal/bases"
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/multihash"
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/types"
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/utils"
|
||||
)
|
||||
|
||||
var (
|
||||
errEmptyBytes = errors.New("empty bytes")
|
||||
errInvalidInputType = errors.New("invalid input type for bytes")
|
||||
)
|
||||
|
||||
type CID struct {
|
||||
multibase.Multibase
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
|
||||
func New(Type types.CIDType, Hash multihash.Multihash, Size uint32) *CID {
|
||||
c := &CID{
|
||||
Type: Type,
|
||||
Hash: Hash,
|
||||
Size: Size,
|
||||
}
|
||||
m := multibase.New(c)
|
||||
c.Multibase = m
|
||||
|
||||
return c
|
||||
}
|
||||
|
||||
func (cid *CID) getPrefixBytes() []byte {
|
||||
return []byte{byte(cid.Type)}
|
||||
}
|
||||
|
||||
func (cid *CID) ToBytes() []byte {
|
||||
if cid.Type == types.CIDTypeBridge {
|
||||
return cid.Hash.FullBytes
|
||||
} else if cid.Type == types.CIDTypeRaw {
|
||||
sizeBytes := utils.EncodeEndian(cid.Size, 8)
|
||||
|
||||
for len(sizeBytes) > 0 && sizeBytes[len(sizeBytes)-1] == 0 {
|
||||
sizeBytes = sizeBytes[:len(sizeBytes)-1]
|
||||
}
|
||||
if len(sizeBytes) == 0 {
|
||||
sizeBytes = []byte{0}
|
||||
}
|
||||
|
||||
return utils.ConcatBytes(cid.getPrefixBytes(), cid.Hash.FullBytes, sizeBytes)
|
||||
}
|
||||
|
||||
return utils.ConcatBytes(cid.getPrefixBytes(), cid.Hash.FullBytes)
|
||||
}
|
||||
|
||||
func Decode(cid string) (*CID, error) {
|
||||
decodedBytes, err := multibase.DecodeString(cid)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cidInstance, err := initCID(decodedBytes)
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return cidInstance, nil
|
||||
}
|
||||
|
||||
func FromRegistry(bytes []byte) (*CID, error) {
|
||||
if len(bytes) == 0 {
|
||||
return nil, errEmptyBytes
|
||||
}
|
||||
|
||||
registryType := types.RegistryType(bytes[0])
|
||||
if _, exists := types.RegistryTypeMap[registryType]; !exists {
|
||||
return nil, fmt.Errorf("invalid registry type %d", bytes[0])
|
||||
}
|
||||
|
||||
bytes = bytes[1:]
|
||||
|
||||
cidInstance, err := initCID(bytes)
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return cidInstance, nil
|
||||
}
|
||||
|
||||
func FromBytes(bytes []byte) (*CID, error) {
|
||||
return initCID(bytes)
|
||||
}
|
||||
|
||||
func FromHash(bytes interface{}, size uint32, cidType types.CIDType) (*CID, error) {
|
||||
var (
|
||||
byteSlice []byte
|
||||
err error
|
||||
)
|
||||
|
||||
switch v := bytes.(type) {
|
||||
case string:
|
||||
byteSlice, err = hex.DecodeString(v)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
case []byte:
|
||||
byteSlice = v
|
||||
default:
|
||||
return nil, errInvalidInputType
|
||||
}
|
||||
|
||||
if _, exists := types.CIDTypeMap[cidType]; !exists {
|
||||
return nil, fmt.Errorf("invalid hash type %d", cidType)
|
||||
}
|
||||
|
||||
return New(cidType, *multihash.New(byteSlice), size), nil
|
||||
}
|
||||
|
||||
func Verify(bytes interface{}) bool {
|
||||
var (
|
||||
byteSlice []byte
|
||||
err error
|
||||
)
|
||||
|
||||
switch v := bytes.(type) {
|
||||
case string:
|
||||
byteSlice, err = multibase.DecodeString(v) // Assuming MultibaseDecodeString function is defined
|
||||
if err != nil {
|
||||
return false
|
||||
}
|
||||
case []byte:
|
||||
byteSlice = v
|
||||
default:
|
||||
return false
|
||||
}
|
||||
|
||||
_, err = initCID(byteSlice)
|
||||
return err == nil
|
||||
}
|
||||
|
||||
func (cid *CID) CopyWith(newType int, newSize uint32) (*CID, error) {
|
||||
if newType == 0 {
|
||||
newType = int(cid.Type)
|
||||
}
|
||||
|
||||
if _, exists := types.CIDTypeMap[types.CIDType(newType)]; !exists {
|
||||
return nil, fmt.Errorf("invalid cid type %d", newType)
|
||||
}
|
||||
|
||||
return New(types.CIDType(newType), cid.Hash, newSize), nil
|
||||
}
|
||||
|
||||
func (cid *CID) ToRegistryEntry() []byte {
|
||||
registryType := types.RegistryTypeCID
|
||||
cidBytes := cid.ToBytes()
|
||||
return utils.ConcatBytes([]byte{byte(registryType)}, cidBytes)
|
||||
}
|
||||
|
||||
func (cid *CID) ToRegistryCID() ([]byte, error) {
|
||||
registryCIDType := types.CIDTypeResolver
|
||||
copiedCID, err := cid.CopyWith(int(registryCIDType), cid.Size)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return copiedCID.ToBytes(), nil
|
||||
}
|
||||
|
||||
func (cid *CID) ToString() (string, error) {
|
||||
if cid.Type == types.CIDTypeBridge {
|
||||
return cid.Hash.ToString()
|
||||
}
|
||||
|
||||
return bases.ToBase58BTC(cid.ToBytes())
|
||||
}
|
||||
|
||||
func (cid *CID) Equals(other *CID) bool {
|
||||
return bytes.Equal(cid.ToBytes(), other.ToBytes())
|
||||
}
|
||||
|
||||
func (cid *CID) HashCode() int {
|
||||
fullBytes := cid.ToBytes()
|
||||
if len(fullBytes) < 4 {
|
||||
return 0
|
||||
}
|
||||
|
||||
return int(fullBytes[0]) +
|
||||
int(fullBytes[1])<<8 +
|
||||
int(fullBytes[2])<<16 +
|
||||
int(fullBytes[3])<<24
|
||||
}
|
||||
|
||||
func FromRegistryPublicKey(pubkey interface{}) (*CID, error) {
|
||||
return FromHash(pubkey, 0, types.CIDTypeResolver)
|
||||
}
|
||||
|
||||
func initCID(bytes []byte) (*CID, error) {
|
||||
if len(bytes) == 0 {
|
||||
return nil, errEmptyBytes
|
||||
}
|
||||
|
||||
cidType := types.CIDType(bytes[0])
|
||||
if cidType == types.CIDTypeBridge {
|
||||
hash := multihash.New(bytes[1:35])
|
||||
return New(cidType, *hash, 0), nil
|
||||
}
|
||||
|
||||
hashBytes := bytes[1:34]
|
||||
hash := multihash.New(hashBytes)
|
||||
|
||||
var size uint32
|
||||
if len(bytes) > 34 {
|
||||
sizeBytes := bytes[34:]
|
||||
sizeValue := utils.DecodeEndian(sizeBytes)
|
||||
size = sizeValue
|
||||
}
|
||||
|
||||
if _, exists := types.CIDTypeMap[cidType]; !exists {
|
||||
return nil, fmt.Errorf("invalid cid type %d", cidType)
|
||||
}
|
||||
|
||||
return New(cidType, *hash, size), nil
|
||||
}
|
||||
|
|
@ -0,0 +1,476 @@
|
|||
package cid
|
||||
|
||||
import (
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/cid/multibase"
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/internal/testdata"
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/multihash"
|
||||
"git.lumeweb.com/LumeWeb/libs5-go/types"
|
||||
"reflect"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestCID_CopyWith(t *testing.T) {
|
||||
type fields struct {
|
||||
Multibase multibase.Multibase
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
type args struct {
|
||||
newType int
|
||||
newSize uint32
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
fields fields
|
||||
args args
|
||||
want *CID
|
||||
wantErr bool
|
||||
}{
|
||||
// TODO: Add test cases.
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cid := &CID{
|
||||
Multibase: tt.fields.Multibase,
|
||||
Type: tt.fields.Type,
|
||||
Hash: tt.fields.Hash,
|
||||
Size: tt.fields.Size,
|
||||
}
|
||||
got, err := cid.CopyWith(tt.args.newType, tt.args.newSize)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("CopyWith() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("CopyWith() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCID_Equals(t *testing.T) {
|
||||
type fields struct {
|
||||
Multibase multibase.Multibase
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
type args struct {
|
||||
other *CID
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
fields fields
|
||||
args args
|
||||
want bool
|
||||
}{
|
||||
// TODO: Add test cases.
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cid := &CID{
|
||||
Multibase: tt.fields.Multibase,
|
||||
Type: tt.fields.Type,
|
||||
Hash: tt.fields.Hash,
|
||||
Size: tt.fields.Size,
|
||||
}
|
||||
if got := cid.Equals(tt.args.other); got != tt.want {
|
||||
t.Errorf("Equals() = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCID_HashCode(t *testing.T) {
|
||||
type fields struct {
|
||||
Multibase multibase.Multibase
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
fields fields
|
||||
want int
|
||||
}{
|
||||
// TODO: Add test cases.
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cid := &CID{
|
||||
Multibase: tt.fields.Multibase,
|
||||
Type: tt.fields.Type,
|
||||
Hash: tt.fields.Hash,
|
||||
Size: tt.fields.Size,
|
||||
}
|
||||
if got := cid.HashCode(); got != tt.want {
|
||||
t.Errorf("HashCode() = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/*func TestCID_ToBytes(t *testing.T) {
|
||||
FromHash(testdata.RawBase58CID)
|
||||
|
||||
println(len(testdata.RawCIDBytes))
|
||||
println(utils.DecodeEndian(testdata.RawCIDBytes[35:]))
|
||||
return
|
||||
type fields struct {
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
fields fields
|
||||
want []byte
|
||||
}{
|
||||
{
|
||||
name: "Bridge CID",
|
||||
fields: fields{
|
||||
Type: types.CIDTypeBridge,
|
||||
Hash: multihash.New(), // Replace with a valid hash value
|
||||
},
|
||||
want: , // Replace with the expected byte output for Bridge CID
|
||||
},
|
||||
{
|
||||
name: "Raw CID with Non-Zero Size",
|
||||
fields: fields{
|
||||
Type: types.CIDTypeRaw,
|
||||
Hash: *multihash.New(testdata.RawCIDBytes[1:34]),
|
||||
Size: utils.DecodeEndian(testdata.RawCIDBytes[34:]),
|
||||
},
|
||||
want: testdata.RawCIDBytes,
|
||||
},
|
||||
{
|
||||
name: "Raw CID with Zero Size",
|
||||
fields: fields{
|
||||
Type: types.CIDTypeRaw,
|
||||
Hash: yourHashValue, // Replace with a valid hash value
|
||||
Size: 0, // Zero size
|
||||
},
|
||||
want: yourExpectedBytesForRawCIDWithZeroSize, // Replace with the expected byte output
|
||||
},
|
||||
{
|
||||
name: "Default CID",
|
||||
fields: fields{
|
||||
Type: types.CIDTypeDefault,
|
||||
Hash: yourHashValue, // Replace with a valid hash value
|
||||
},
|
||||
want: yourExpectedBytesForDefaultCID, // Replace with the expected byte output for Default CID
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cid := &CID{
|
||||
Type: tt.fields.Type,
|
||||
Hash: tt.fields.Hash,
|
||||
Size: tt.fields.Size,
|
||||
}
|
||||
m := multibase.New(cid)
|
||||
cid.Multibase = m
|
||||
if got := cid.ToBytes(); !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("ToBytes() = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}*/
|
||||
|
||||
func TestCID_ToRegistryCID(t *testing.T) {
|
||||
type fields struct {
|
||||
Multibase multibase.Multibase
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
fields fields
|
||||
want []byte
|
||||
wantErr bool
|
||||
}{
|
||||
// TODO: Add test cases.
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cid := &CID{
|
||||
Multibase: tt.fields.Multibase,
|
||||
Type: tt.fields.Type,
|
||||
Hash: tt.fields.Hash,
|
||||
Size: tt.fields.Size,
|
||||
}
|
||||
got, err := cid.ToRegistryCID()
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("ToRegistryCID() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("ToRegistryCID() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCID_ToRegistryEntry(t *testing.T) {
|
||||
type fields struct {
|
||||
Multibase multibase.Multibase
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
fields fields
|
||||
want []byte
|
||||
}{
|
||||
// TODO: Add test cases.
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cid := &CID{
|
||||
Multibase: tt.fields.Multibase,
|
||||
Type: tt.fields.Type,
|
||||
Hash: tt.fields.Hash,
|
||||
Size: tt.fields.Size,
|
||||
}
|
||||
if got := cid.ToRegistryEntry(); !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("ToRegistryEntry() = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCID_ToString(t *testing.T) {
|
||||
type fields struct {
|
||||
Multibase multibase.Multibase
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
fields fields
|
||||
want string
|
||||
wantErr bool
|
||||
}{
|
||||
// TODO: Add test cases.
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cid := &CID{
|
||||
Multibase: tt.fields.Multibase,
|
||||
Type: tt.fields.Type,
|
||||
Hash: tt.fields.Hash,
|
||||
Size: tt.fields.Size,
|
||||
}
|
||||
got, err := cid.ToString()
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("ToString() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if got != tt.want {
|
||||
t.Errorf("ToString() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestCID_getPrefixBytes(t *testing.T) {
|
||||
type fields struct {
|
||||
Multibase multibase.Multibase
|
||||
Type types.CIDType
|
||||
Hash multihash.Multihash
|
||||
Size uint32
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
fields fields
|
||||
want []byte
|
||||
}{
|
||||
// TODO: Add test cases.
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
cid := &CID{
|
||||
Multibase: tt.fields.Multibase,
|
||||
Type: tt.fields.Type,
|
||||
Hash: tt.fields.Hash,
|
||||
Size: tt.fields.Size,
|
||||
}
|
||||
if got := cid.getPrefixBytes(); !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("getPrefixBytes() = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDecode(t *testing.T) {
|
||||
type args struct {
|
||||
cid string
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
args args
|
||||
want *CID
|
||||
wantErr bool
|
||||
}{
|
||||
/* {
|
||||
name: "Valid Bridge CID",
|
||||
args:args {cid: ""},
|
||||
want: nil,
|
||||
wantErr: false,
|
||||
},*/
|
||||
|
||||
{
|
||||
name: "Valid Raw Base 58 CID",
|
||||
args: args{cid: testdata.RawBase58CID},
|
||||
want: New(types.CIDTypeRaw, *multihash.New(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Valid Media 58 CID",
|
||||
args: args{cid: testdata.MediaBase58CID},
|
||||
want: New(types.CIDTypeMetadataMedia, *multihash.New(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Valid Resolver CID",
|
||||
args: args{cid: testdata.ResolverBase58CID},
|
||||
want: New(types.CIDTypeResolver, *multihash.New(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got, err := Decode(tt.args.cid)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("DecodeCID() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("DecodeCID() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestFromBytes(t *testing.T) {
|
||||
type args struct {
|
||||
bytes []byte
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
args args
|
||||
want *CID
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Valid Raw Base 58 CID",
|
||||
args: args{bytes: testdata.RawCIDBytes},
|
||||
want: New(types.CIDTypeRaw, *multihash.New(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Valid Media 58 CID",
|
||||
args: args{bytes: testdata.MediaCIDBytes},
|
||||
want: New(types.CIDTypeMetadataMedia, *multihash.New(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Valid Resolver CID",
|
||||
args: args{bytes: testdata.ResolverCIDBytes},
|
||||
want: New(types.CIDTypeResolver, *multihash.New(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got, err := FromBytes(tt.args.bytes)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("FromBytes() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("FromBytes() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestFromHash(t *testing.T) {
|
||||
type args struct {
|
||||
bytes interface{}
|
||||
size uint32
|
||||
cidType types.CIDType
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
args args
|
||||
want *CID
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Valid Raw Base 58 CID",
|
||||
args: args{bytes: testdata.RawCIDBytes[1:34], size: testdata.RawCIDSize, cidType: types.CIDTypeRaw},
|
||||
want: New(types.CIDTypeRaw, *multihash.New(testdata.RawCIDBytes[1:34]), testdata.RawCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Valid Media 58 CID",
|
||||
args: args{bytes: testdata.MediaCIDBytes[1:34], size: testdata.MediaCIDSize, cidType: types.CIDTypeMetadataMedia},
|
||||
want: New(types.CIDTypeMetadataMedia, *multihash.New(testdata.MediaCIDBytes[1:34]), testdata.MediaCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "Valid Resolver CID",
|
||||
args: args{bytes: testdata.ResolverCIDBytes[1:34], size: testdata.ResolverCIDSize, cidType: types.CIDTypeResolver},
|
||||
want: New(types.CIDTypeResolver, *multihash.New(testdata.ResolverCIDBytes[1:34]), testdata.ResolverCIDSize),
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got, err := FromHash(tt.args.bytes, tt.args.size, tt.args.cidType)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("FromHash() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("FromHash() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestFromRegistry(t *testing.T) {
|
||||
type args struct {
|
||||
bytes []byte
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
args args
|
||||
want *CID
|
||||
wantErr bool
|
||||
}{
|
||||
{
|
||||
name: "Valid Resolver Data",
|
||||
args: args{bytes: testdata.ResolverDataBytes},
|
||||
want: New(types.CIDTypeMetadataWebapp, *multihash.New(testdata.ResolverDataBytes[2:35]), testdata.ResolverDataSize),
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got, err := FromRegistry(tt.args.bytes)
|
||||
if (err != nil) != tt.wantErr {
|
||||
t.Errorf("FromRegistry() error = %v, wantErr %v", err, tt.wantErr)
|
||||
return
|
||||
}
|
||||
if !reflect.DeepEqual(got, tt.want) {
|
||||
t.Errorf("FromRegistry() got = %v, want %v", got, tt.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue