code.vegaprotocol.io/vega@v0.79.0/cmd/vegawallet/commands/message_verify_test.go (about)

     1  // Copyright (C) 2023 Gobalsky Labs Limited
     2  //
     3  // This program is free software: you can redistribute it and/or modify
     4  // it under the terms of the GNU Affero General Public License as
     5  // published by the Free Software Foundation, either version 3 of the
     6  // License, or (at your option) any later version.
     7  //
     8  // This program is distributed in the hope that it will be useful,
     9  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    10  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    11  // GNU Affero General Public License for more details.
    12  //
    13  // You should have received a copy of the GNU Affero General Public License
    14  // along with this program.  If not, see <http://www.gnu.org/licenses/>.
    15  
    16  package cmd_test
    17  
    18  import (
    19  	"encoding/base64"
    20  	"testing"
    21  
    22  	cmd "code.vegaprotocol.io/vega/cmd/vegawallet/commands"
    23  	"code.vegaprotocol.io/vega/cmd/vegawallet/commands/flags"
    24  	vgrand "code.vegaprotocol.io/vega/libs/rand"
    25  	"code.vegaprotocol.io/vega/wallet/api"
    26  
    27  	"github.com/stretchr/testify/assert"
    28  	"github.com/stretchr/testify/require"
    29  )
    30  
    31  func TestVerifyMessageFlags(t *testing.T) {
    32  	t.Run("Valid flags succeeds", testVerifyMessageFlagsValidFlagsSucceeds)
    33  	t.Run("Missing public key fails", testVerifyMessageFlagsMissingPubKeyFails)
    34  	t.Run("Missing message fails", testVerifyMessageFlagsMissingMessageFails)
    35  	t.Run("Malformed message fails", testVerifyMessageFlagsMalformedMessageFails)
    36  	t.Run("Missing signature fails", testVerifyMessageFlagsMissingSignatureFails)
    37  	t.Run("Malformed signature fails", testVerifyMessageFlagsMalformedSignatureFails)
    38  }
    39  
    40  func testVerifyMessageFlagsValidFlagsSucceeds(t *testing.T) {
    41  	// given
    42  	pubKey := vgrand.RandomStr(20)
    43  	decodedMessage := []byte(vgrand.RandomStr(20))
    44  	decodedSignature := []byte(vgrand.RandomStr(20))
    45  
    46  	f := &cmd.VerifyMessageFlags{
    47  		PubKey:    pubKey,
    48  		Message:   base64.StdEncoding.EncodeToString(decodedMessage),
    49  		Signature: base64.StdEncoding.EncodeToString(decodedSignature),
    50  	}
    51  
    52  	expectedReq := api.AdminVerifyMessageParams{
    53  		PublicKey:        pubKey,
    54  		EncodedMessage:   f.Message,
    55  		EncodedSignature: f.Signature,
    56  	}
    57  
    58  	// when
    59  	req, err := f.Validate()
    60  
    61  	// then
    62  	require.NoError(t, err)
    63  	require.NotNil(t, req)
    64  	assert.Equal(t, expectedReq, req)
    65  }
    66  
    67  func testVerifyMessageFlagsMissingPubKeyFails(t *testing.T) {
    68  	// given
    69  	f := newVerifyMessageFlags(t)
    70  	f.PubKey = ""
    71  
    72  	// when
    73  	req, err := f.Validate()
    74  
    75  	// then
    76  	assert.ErrorIs(t, err, flags.MustBeSpecifiedError("pubkey"))
    77  	assert.Empty(t, req)
    78  }
    79  
    80  func testVerifyMessageFlagsMissingMessageFails(t *testing.T) {
    81  	// given
    82  	f := newVerifyMessageFlags(t)
    83  	f.Message = ""
    84  
    85  	// when
    86  	req, err := f.Validate()
    87  
    88  	// then
    89  	assert.ErrorIs(t, err, flags.MustBeSpecifiedError("message"))
    90  	assert.Empty(t, req)
    91  }
    92  
    93  func testVerifyMessageFlagsMalformedMessageFails(t *testing.T) {
    94  	// given
    95  	f := newVerifyMessageFlags(t)
    96  	f.Message = vgrand.RandomStr(5)
    97  
    98  	// when
    99  	req, err := f.Validate()
   100  
   101  	// then
   102  	assert.ErrorIs(t, err, flags.MustBase64EncodedError("message"))
   103  	assert.Empty(t, req)
   104  }
   105  
   106  func testVerifyMessageFlagsMissingSignatureFails(t *testing.T) {
   107  	// given
   108  	f := newVerifyMessageFlags(t)
   109  	f.Signature = ""
   110  
   111  	// when
   112  	req, err := f.Validate()
   113  
   114  	// then
   115  	assert.ErrorIs(t, err, flags.MustBeSpecifiedError("signature"))
   116  	assert.Empty(t, req)
   117  }
   118  
   119  func testVerifyMessageFlagsMalformedSignatureFails(t *testing.T) {
   120  	// given
   121  	f := newVerifyMessageFlags(t)
   122  	f.Signature = vgrand.RandomStr(5)
   123  
   124  	// when
   125  	req, err := f.Validate()
   126  
   127  	// then
   128  	assert.ErrorIs(t, err, flags.MustBase64EncodedError("signature"))
   129  	assert.Empty(t, req)
   130  }
   131  
   132  func newVerifyMessageFlags(t *testing.T) *cmd.VerifyMessageFlags {
   133  	t.Helper()
   134  
   135  	pubKey := vgrand.RandomStr(20)
   136  	decodedMessage := []byte(vgrand.RandomStr(20))
   137  	decodedSignature := []byte(vgrand.RandomStr(20))
   138  
   139  	return &cmd.VerifyMessageFlags{
   140  		PubKey:    pubKey,
   141  		Message:   base64.StdEncoding.EncodeToString(decodedMessage),
   142  		Signature: base64.StdEncoding.EncodeToString(decodedSignature),
   143  	}
   144  }