github.com/onflow/flow-go@v0.33.17/ledger/common/convert/convert_test.go (about)

     1  package convert_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/require"
     7  
     8  	"github.com/onflow/flow-go/ledger"
     9  	"github.com/onflow/flow-go/ledger/common/convert"
    10  	"github.com/onflow/flow-go/model/flow"
    11  	"github.com/onflow/flow-go/utils/unittest"
    12  )
    13  
    14  func TestLedgerKeyToRegisterID(t *testing.T) {
    15  	expectedRegisterID := unittest.RegisterIDFixture()
    16  
    17  	key := ledger.Key{
    18  		KeyParts: []ledger.KeyPart{
    19  			{
    20  				Type:  convert.KeyPartOwner,
    21  				Value: []byte(expectedRegisterID.Owner),
    22  			},
    23  			{
    24  				Type:  convert.KeyPartKey,
    25  				Value: []byte("key"),
    26  			},
    27  		},
    28  	}
    29  
    30  	registerID, err := convert.LedgerKeyToRegisterID(key)
    31  	require.NoError(t, err)
    32  	require.Equal(t, expectedRegisterID, registerID)
    33  }
    34  
    35  func TestLedgerKeyToRegisterID_Global(t *testing.T) {
    36  	key := ledger.Key{
    37  		KeyParts: []ledger.KeyPart{
    38  			{
    39  				Type:  convert.KeyPartOwner,
    40  				Value: []byte(""),
    41  			},
    42  			{
    43  				Type:  convert.KeyPartKey,
    44  				Value: []byte("uuid"),
    45  			},
    46  		},
    47  	}
    48  
    49  	expectedRegisterID := flow.UUIDRegisterID(0)
    50  	registerID, err := convert.LedgerKeyToRegisterID(key)
    51  	require.NoError(t, err)
    52  	require.Equal(t, expectedRegisterID, registerID)
    53  }
    54  
    55  func TestLedgerKeyToRegisterID_Error(t *testing.T) {
    56  	key := ledger.Key{
    57  		KeyParts: []ledger.KeyPart{
    58  			{
    59  				Type:  999, // Invalid type
    60  				Value: []byte("owner"),
    61  			},
    62  			{
    63  				Type:  convert.KeyPartKey,
    64  				Value: []byte("key"),
    65  			},
    66  		},
    67  	}
    68  
    69  	_, err := convert.LedgerKeyToRegisterID(key)
    70  	require.Error(t, err)
    71  	require.ErrorIs(t, err, convert.UnexpectedLedgerKeyFormat)
    72  }
    73  
    74  func TestRegisterIDToLedgerKey(t *testing.T) {
    75  	registerID := unittest.RegisterIDFixture()
    76  	expectedKey := ledger.Key{
    77  		KeyParts: []ledger.KeyPart{
    78  			{
    79  				Type: convert.KeyPartOwner,
    80  				// Note: the owner field is extended to address length during NewRegisterID
    81  				// so we have to do the same here
    82  				Value: []byte(registerID.Owner),
    83  			},
    84  			{
    85  				Type:  convert.KeyPartKey,
    86  				Value: []byte("key"),
    87  			},
    88  		},
    89  	}
    90  
    91  	key := convert.RegisterIDToLedgerKey(registerID)
    92  	require.Equal(t, expectedKey, key)
    93  }
    94  
    95  func TestRegisterIDToLedgerKey_Global(t *testing.T) {
    96  	registerID := flow.UUIDRegisterID(0)
    97  	expectedKey := ledger.Key{
    98  		KeyParts: []ledger.KeyPart{
    99  			{
   100  				Type:  convert.KeyPartOwner,
   101  				Value: []byte(""),
   102  			},
   103  			{
   104  				Type:  convert.KeyPartKey,
   105  				Value: []byte("uuid"),
   106  			},
   107  		},
   108  	}
   109  
   110  	key := convert.RegisterIDToLedgerKey(registerID)
   111  	require.Equal(t, expectedKey, key)
   112  }
   113  
   114  func TestPayloadToRegister(t *testing.T) {
   115  	expected := unittest.RegisterIDFixture()
   116  	t.Run("can convert", func(t *testing.T) {
   117  		value := []byte("value")
   118  		p := ledger.NewPayload(
   119  			ledger.NewKey(
   120  				[]ledger.KeyPart{
   121  					ledger.NewKeyPart(convert.KeyPartOwner, []byte(expected.Owner)),
   122  					ledger.NewKeyPart(convert.KeyPartKey, []byte(expected.Key)),
   123  				},
   124  			),
   125  			value,
   126  		)
   127  		regID, regValue, err := convert.PayloadToRegister(p)
   128  		require.NoError(t, err)
   129  		require.Equal(t, expected, regID)
   130  		require.Equal(t, value, regValue)
   131  	})
   132  
   133  	t.Run("global key", func(t *testing.T) {
   134  		value := []byte("1")
   135  		p := ledger.NewPayload(
   136  			ledger.NewKey(
   137  				[]ledger.KeyPart{
   138  					ledger.NewKeyPart(convert.KeyPartOwner, []byte("")),
   139  					ledger.NewKeyPart(convert.KeyPartKey, []byte("uuid")),
   140  				},
   141  			),
   142  			value,
   143  		)
   144  		regID, regValue, err := convert.PayloadToRegister(p)
   145  		require.NoError(t, err)
   146  		require.Equal(t, flow.NewRegisterID(flow.EmptyAddress, "uuid"), regID)
   147  		require.Equal(t, "", regID.Owner)
   148  		require.Equal(t, "uuid", regID.Key)
   149  		require.True(t, regID.IsInternalState())
   150  		require.Equal(t, value, regValue)
   151  	})
   152  
   153  	t.Run("empty payload", func(t *testing.T) {
   154  		p := ledger.EmptyPayload()
   155  		_, _, err := convert.PayloadToRegister(p)
   156  		require.Error(t, err)
   157  	})
   158  }