github.com/nats-io/nsc@v0.0.0-20221206222106-35db9400b257/cmd/generatenkey_test.go (about)

     1  /*
     2   * Copyright 2018-2020 The NATS Authors
     3   * Licensed under the Apache License, Version 2.0 (the "License");
     4   * you may not use this file except in compliance with the License.
     5   * You may obtain a copy of the License at
     6   *
     7   * http://www.apache.org/licenses/LICENSE-2.0
     8   *
     9   * Unless required by applicable law or agreed to in writing, software
    10   * distributed under the License is distributed on an "AS IS" BASIS,
    11   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12   * See the License for the specific language governing permissions and
    13   * limitations under the License.
    14   */
    15  
    16  package cmd
    17  
    18  import (
    19  	"strings"
    20  	"testing"
    21  
    22  	"github.com/nats-io/nkeys"
    23  	"github.com/nats-io/nsc/cmd/store"
    24  	"github.com/stretchr/testify/require"
    25  )
    26  
    27  func Test_GenerateOperatorNKey(t *testing.T) {
    28  	ts := NewTestStore(t, "X")
    29  	defer ts.Done(t)
    30  
    31  	_, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator")
    32  	require.NoError(t, err)
    33  	lines := strings.Split(stderr, "\n")
    34  	require.True(t, len(lines) >= 2)
    35  
    36  	// seed
    37  	kp, err := nkeys.FromSeed([]byte(lines[0]))
    38  	require.NoError(t, err)
    39  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteOperator, kp))
    40  	_, err = kp.Seed()
    41  	require.NoError(t, err)
    42  
    43  	// pk
    44  	pk, err := nkeys.FromPublicKey(lines[1])
    45  	require.NoError(t, err)
    46  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteOperator, pk))
    47  	_, err = pk.Seed()
    48  	require.Error(t, err)
    49  }
    50  
    51  func Test_GenerateNKeyAndStoreDoesntPrint(t *testing.T) {
    52  	ts := NewTestStore(t, "X")
    53  	defer ts.Done(t)
    54  
    55  	_, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator", "--store")
    56  	require.NoError(t, err)
    57  	lines := strings.Split(stderr, "\n")
    58  	require.True(t, len(lines) == 4)
    59  	require.Equal(t, lines[2], "")
    60  	require.Equal(t, lines[3], "")
    61  
    62  	// pk only
    63  	pk := strings.TrimSpace(lines[0])
    64  	kp, err := nkeys.FromPublicKey(pk)
    65  	require.NoError(t, err)
    66  	require.Equal(t, string(lines[0][0]), "O")
    67  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteOperator, kp))
    68  	require.NoError(t, err)
    69  
    70  	// check this is the file
    71  	chunks := strings.Split(lines[1], " ")
    72  	fp := chunks[3]
    73  	fp = strings.TrimSpace(fp)
    74  	fp2 := ts.KeyStore.GetKeyPath(pk)
    75  	require.Equal(t, fp, fp2)
    76  }
    77  
    78  func Test_GenerateNKeyAndStore(t *testing.T) {
    79  	ts := NewTestStore(t, "X")
    80  	defer ts.Done(t)
    81  
    82  	kp, err := nkeys.CreateOperator()
    83  	require.NoError(t, err)
    84  	_, err = ts.KeyStore.Store(kp)
    85  	require.NoError(t, err)
    86  	gpk, err := kp.PublicKey()
    87  	require.NoError(t, err)
    88  	gsk, err := kp.Seed()
    89  	require.NoError(t, err)
    90  
    91  	seed, err := ts.KeyStore.GetSeed(gpk)
    92  	require.NoError(t, err)
    93  	require.Equal(t, seed, string(gsk))
    94  
    95  	// pk
    96  	pk, err := ts.KeyStore.GetPublicKey(gpk)
    97  	require.NoError(t, err)
    98  	require.Equal(t, pk, gpk)
    99  }
   100  
   101  func Test_GenerateAccountNKey(t *testing.T) {
   102  	ts := NewTestStore(t, "X")
   103  	defer ts.Done(t)
   104  
   105  	_, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--account")
   106  	require.NoError(t, err)
   107  	lines := strings.Split(stderr, "\n")
   108  	require.True(t, len(lines) >= 2)
   109  
   110  	// seed
   111  	kp, err := nkeys.FromSeed([]byte(lines[0]))
   112  	require.NoError(t, err)
   113  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteAccount, kp))
   114  	_, err = kp.Seed()
   115  	require.NoError(t, err)
   116  
   117  	// pk
   118  	pk, err := nkeys.FromPublicKey(lines[1])
   119  	require.NoError(t, err)
   120  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteAccount, pk))
   121  	_, err = pk.Seed()
   122  	require.Error(t, err)
   123  }
   124  
   125  func Test_GenerateUserNKey(t *testing.T) {
   126  	ts := NewTestStore(t, "X")
   127  	defer ts.Done(t)
   128  
   129  	_, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--user")
   130  	require.NoError(t, err)
   131  	lines := strings.Split(stderr, "\n")
   132  	require.True(t, len(lines) >= 2)
   133  
   134  	// seed
   135  	kp, err := nkeys.FromSeed([]byte(lines[0]))
   136  	require.NoError(t, err)
   137  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteUser, kp))
   138  	_, err = kp.Seed()
   139  	require.NoError(t, err)
   140  
   141  	// pk
   142  	pk, err := nkeys.FromPublicKey(lines[1])
   143  	require.NoError(t, err)
   144  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteUser, pk))
   145  	_, err = pk.Seed()
   146  	require.Error(t, err)
   147  }
   148  
   149  func Test_GenerateAllNKeys(t *testing.T) {
   150  	ts := NewTestStore(t, "X")
   151  	defer ts.Done(t)
   152  
   153  	_, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator", "--account", "--user")
   154  	require.NoError(t, err)
   155  	lines := strings.Split(stderr, "\n")
   156  	require.True(t, len(lines) > 9)
   157  
   158  	kp, err := nkeys.FromSeed([]byte(lines[0]))
   159  	require.NoError(t, err)
   160  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteOperator, kp))
   161  
   162  	kp, err = nkeys.FromSeed([]byte(lines[3]))
   163  	require.NoError(t, err)
   164  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteAccount, kp))
   165  
   166  	kp, err = nkeys.FromSeed([]byte(lines[6]))
   167  	require.NoError(t, err)
   168  	require.True(t, store.KeyPairTypeOk(nkeys.PrefixByteUser, kp))
   169  }