github.com/MetalBlockchain/metalgo@v1.11.9/vms/secp256k1fx/output_owners_test.go (about)

     1  // Copyright (C) 2019-2024, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package secp256k1fx
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/require"
    10  
    11  	"github.com/MetalBlockchain/metalgo/ids"
    12  )
    13  
    14  func TestOutputOwnersVerify(t *testing.T) {
    15  	tests := []struct {
    16  		name        string
    17  		out         *OutputOwners
    18  		expectedErr error
    19  	}{
    20  		{
    21  			name:        "nil",
    22  			out:         nil,
    23  			expectedErr: ErrNilOutput,
    24  		},
    25  		{
    26  			name: "threshold > num addrs",
    27  			out: &OutputOwners{
    28  				Threshold: 1,
    29  				Addrs:     []ids.ShortID{},
    30  			},
    31  			expectedErr: ErrOutputUnspendable,
    32  		},
    33  		{
    34  			name: "unoptimized",
    35  			out: &OutputOwners{
    36  				Threshold: 0,
    37  				Addrs:     []ids.ShortID{ids.GenerateTestShortID()},
    38  			},
    39  			expectedErr: ErrOutputUnoptimized,
    40  		},
    41  		{
    42  			name: "not sorted",
    43  			out: &OutputOwners{
    44  				Threshold: 1,
    45  				Addrs:     []ids.ShortID{{2}, {1}},
    46  			},
    47  			expectedErr: ErrAddrsNotSortedUnique,
    48  		},
    49  		{
    50  			name: "not unique",
    51  			out: &OutputOwners{
    52  				Threshold: 1,
    53  				Addrs:     []ids.ShortID{{2}, {2}},
    54  			},
    55  			expectedErr: ErrAddrsNotSortedUnique,
    56  		},
    57  		{
    58  			name: "passes verification",
    59  			out: &OutputOwners{
    60  				Threshold: 1,
    61  				Addrs:     []ids.ShortID{{2}},
    62  			},
    63  			expectedErr: nil,
    64  		},
    65  	}
    66  
    67  	for _, tt := range tests {
    68  		t.Run(tt.name, func(t *testing.T) {
    69  			require := require.New(t)
    70  			err := tt.out.Verify()
    71  			require.ErrorIs(err, tt.expectedErr)
    72  		})
    73  	}
    74  }
    75  
    76  func TestOutputOwnerEquals(t *testing.T) {
    77  	addr1, addr2 := ids.GenerateTestShortID(), ids.GenerateTestShortID()
    78  	tests := []struct {
    79  		name        string
    80  		out1        *OutputOwners
    81  		out2        *OutputOwners
    82  		shouldEqual bool
    83  	}{
    84  		{
    85  			name:        "both nil",
    86  			out1:        nil,
    87  			out2:        nil,
    88  			shouldEqual: true,
    89  		},
    90  		{
    91  			name: "different locktimes",
    92  			out1: &OutputOwners{
    93  				Locktime: 1,
    94  				Addrs:    []ids.ShortID{addr1, addr2},
    95  			},
    96  			out2: &OutputOwners{
    97  				Locktime: 2,
    98  				Addrs:    []ids.ShortID{addr1, addr2},
    99  			},
   100  			shouldEqual: false,
   101  		},
   102  		{
   103  			name: "different thresholds",
   104  			out1: &OutputOwners{
   105  				Threshold: 1,
   106  				Locktime:  1,
   107  				Addrs:     []ids.ShortID{addr1, addr2},
   108  			},
   109  			out2: &OutputOwners{
   110  				Locktime: 1,
   111  				Addrs:    []ids.ShortID{addr1, addr2},
   112  			},
   113  			shouldEqual: false,
   114  		},
   115  		{
   116  			name: "different addresses",
   117  			out1: &OutputOwners{
   118  				Locktime: 1,
   119  				Addrs:    []ids.ShortID{addr1, ids.GenerateTestShortID()},
   120  			},
   121  			out2: &OutputOwners{
   122  				Locktime: 1,
   123  				Addrs:    []ids.ShortID{addr1, addr2},
   124  			},
   125  			shouldEqual: false,
   126  		},
   127  		{
   128  			name: "equal",
   129  			out1: &OutputOwners{
   130  				Locktime: 1,
   131  				Addrs:    []ids.ShortID{addr1, addr2},
   132  			},
   133  			out2: &OutputOwners{
   134  				Locktime: 1,
   135  				Addrs:    []ids.ShortID{addr1, addr2},
   136  			},
   137  			shouldEqual: true,
   138  		},
   139  	}
   140  
   141  	for _, tt := range tests {
   142  		t.Run(tt.name, func(t *testing.T) {
   143  			require := require.New(t)
   144  			require.Equal(tt.shouldEqual, tt.out1.Equals(tt.out2))
   145  			require.Equal(tt.shouldEqual, tt.out2.Equals(tt.out1))
   146  			require.True(tt.out1.Equals(tt.out1)) //nolint:gocritic
   147  			require.True(tt.out2.Equals(tt.out2)) //nolint:gocritic
   148  		})
   149  	}
   150  }
   151  
   152  func TestMarshalJSONDoesNotRequireCtx(t *testing.T) {
   153  	require := require.New(t)
   154  	out := &OutputOwners{
   155  		Threshold: 1,
   156  		Locktime:  2,
   157  		Addrs: []ids.ShortID{
   158  			{1},
   159  			{0},
   160  		},
   161  	}
   162  
   163  	b, err := out.MarshalJSON()
   164  	require.NoError(err)
   165  
   166  	require.Equal(`{"addresses":["6HgC8KRBEhXYbF4riJyJFLSHt37UNuRt","111111111111111111116DBWJs"],"locktime":2,"threshold":1}`, string(b))
   167  }