From 161e43338443efb7c9a1ad4d1c91c53794305044 Mon Sep 17 00:00:00 2001 From: Alberto Ricart Date: Mon, 6 Jan 2025 13:58:49 -0600 Subject: [PATCH] Refactor test command execution to improve readability. Updated command invocations to use consistent argument formatting with slices. This change removes redundant values from returned results, simplifies error handling, and improves code clarity across tests. The output stream for messages is now more deterministic. Signed-off-by: Alberto Ricart --- cmd/accountusercontextparams_test.go | 2 +- cmd/action.go | 16 +++- cmd/action_test.go | 12 +-- cmd/addaccount_test.go | 43 ++++----- cmd/addexport_test.go | 52 +++++----- cmd/addimport_test.go | 76 +++++++-------- cmd/addmapping_test.go | 14 +-- cmd/addoperator_test.go | 49 +++++----- cmd/adduser_test.go | 132 +++++++++++++------------- cmd/cmd_test.go | 58 ++++------- cmd/common.go | 4 + cmd/common_test.go | 28 +++--- cmd/deleteaccount_test.go | 14 +-- cmd/deleteexport_test.go | 8 +- cmd/deleteimport_test.go | 12 +-- cmd/deletemapping_test.go | 30 +++--- cmd/deleteuser_test.go | 18 ++-- cmd/describe.go | 122 +++++++++++++++++++++++- cmd/describeaccount.go | 69 ++------------ cmd/describeaccount_test.go | 130 +++++++++++++------------ cmd/describejwt.go | 104 +++----------------- cmd/describejwt_test.go | 50 +++++----- cmd/describeoperator.go | 75 +++------------ cmd/describeoperator_test.go | 60 ++++++------ cmd/describeuser.go | 91 +++++++----------- cmd/describeuser_test.go | 84 ++++++++-------- cmd/editaccount_test.go | 125 +++++++++++------------- cmd/editauthorization_test.go | 46 ++++----- cmd/editexport_test.go | 22 ++--- cmd/editoperator_test.go | 108 ++++++++++----------- cmd/editscopedsk_test.go | 54 +++++------ cmd/edituser_test.go | 110 +++++++++------------ cmd/env_test.go | 30 +++--- cmd/expirations.go | 4 +- cmd/expirations_test.go | 44 ++++----- cmd/exportkeys_test.go | 24 ++--- cmd/fixenv_test.go | 28 +++--- cmd/generateactivation.go | 11 ++- cmd/generateactivation_test.go | 22 ++--- cmd/generatecontext_test.go | 2 +- cmd/generatecreds.go | 9 +- cmd/generatecreds_test.go | 46 +++++---- cmd/generatediagram.go | 51 ++++++---- cmd/generatediagram_test.go | 35 ++++--- cmd/generatenkey.go | 5 +- cmd/generatenkey_test.go | 20 ++-- cmd/generateprofile_test.go | 20 ++-- cmd/generateserverconfig.go | 7 +- cmd/importaccount_test.go | 43 ++++----- cmd/importkeys_test.go | 17 ++-- cmd/importuser_test.go | 45 +++++---- cmd/init_test.go | 33 ++++--- cmd/keys_test.go | 16 ++-- cmd/list_test.go | 12 +-- cmd/listeditor_test.go | 6 +- cmd/listkeys_test.go | 43 ++++----- cmd/memresolverconfigbuilder_test.go | 15 ++- cmd/migrate_test.go | 8 +- cmd/natsresolverconfigbuilder_test.go | 9 +- cmd/numberparams_test.go | 4 +- cmd/options_test.go | 10 +- cmd/pull_test.go | 49 +++++----- cmd/push_test.go | 100 +++++++++---------- cmd/reissueoperator_test.go | 21 ++-- cmd/rename_test.go | 14 ++- cmd/reqtool.go | 4 +- cmd/revoke_clearactivation_test.go | 39 ++++---- cmd/revoke_listactivation.go | 3 +- cmd/revoke_listactivation_test.go | 67 +++++++------ cmd/revoke_listusers.go | 3 +- cmd/revoke_listusers_test.go | 30 +++--- cmd/revokeactivation_test.go | 35 ++++--- cmd/revokeclearuser_test.go | 30 +++--- cmd/revokeuser_test.go | 44 ++++----- cmd/rtttool.go | 7 +- cmd/rtttool_test.go | 6 +- cmd/select_test.go | 19 ++-- cmd/signerparams_test.go | 16 ++-- cmd/test.go | 13 ++- cmd/test_test.go | 12 +-- cmd/timeparams.go | 2 +- cmd/tools_test.go | 80 +++++++--------- cmd/update.go | 8 +- cmd/update_test.go | 31 +++--- cmd/upgradejwt_test.go | 35 ++++--- cmd/util_test.go | 22 ++--- cmd/validate_test.go | 59 ++++++------ go.mod | 20 ++-- go.sum | 51 +++++----- 89 files changed, 1552 insertions(+), 1705 deletions(-) diff --git a/cmd/accountusercontextparams_test.go b/cmd/accountusercontextparams_test.go index 26afa4a4..0c545d46 100644 --- a/cmd/accountusercontextparams_test.go +++ b/cmd/accountusercontextparams_test.go @@ -59,7 +59,7 @@ func Test_AccountUserContextParams(t *testing.T) { // A, a inputs := []interface{}{0, 0} - _, _, err := ExecuteInteractiveCmd(cmd, inputs) + _, err := ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) require.Equal(t, "A", params.AccountContextParams.Name) require.Equal(t, "a", params.UserContextParams.Name) diff --git a/cmd/action.go b/cmd/action.go index a12c4efc..1c6c2fba 100644 --- a/cmd/action.go +++ b/cmd/action.go @@ -143,7 +143,19 @@ func run(ctx ActionCtx, action interface{}) error { rs, err := e.Run(ctx) if rs != nil { - ctx.CurrentCmd().Println(rs.Message()) + // if we have an error or the reports has an error, send to stderr + // so they can see it + stream := ctx.CurrentCmd().OutOrStdout() + if err != nil { + stream = ctx.CurrentCmd().ErrOrStderr() + } else if store.IsReport(rs) { + r := store.ToReport(rs) + if r.HasErrors() { + stream = ctx.CurrentCmd().ErrOrStderr() + } + } + + _, _ = fmt.Fprintln(stream, rs.Message()) sum, ok := rs.(store.Summarizer) if ok { m, err := sum.Summary() @@ -151,7 +163,7 @@ func run(ctx ActionCtx, action interface{}) error { return err } if m != "" { - ctx.CurrentCmd().Println(strings.TrimSuffix(m, "\n")) + _, _ = fmt.Fprintln(stream, strings.TrimSuffix(m, "\n")) } } } diff --git a/cmd/action_test.go b/cmd/action_test.go index bddb726b..611fad02 100644 --- a/cmd/action_test.go +++ b/cmd/action_test.go @@ -58,7 +58,7 @@ func TestActionContextSet(t *testing.T) { }, } - _, _, err := ExecuteCmd(cmd, "hello", "world") + _, err := ExecuteCmd(cmd, "hello", "world") require.NoError(t, err) } @@ -88,7 +88,7 @@ func TestActionInteractive(t *testing.T) { return nil }, } - _, _, err := ExecuteInteractiveCmd(cmd, []interface{}{}) + _, err := ExecuteInteractiveCmd(cmd, []interface{}{}) require.NoError(t, err) require.Equal(t, 2, count) } @@ -118,7 +118,7 @@ func TestActionNothingToDoEmpty(t *testing.T) { } cmd.Flags().StringVarP(&v, "name", "n", "", "account name") - _, _, err := ExecuteCmd(cmd) + _, err := ExecuteCmd(cmd) require.NoError(t, err) require.True(t, nothingToDo) } @@ -148,7 +148,7 @@ func TestActionNothingToDoSet(t *testing.T) { } cmd.Flags().StringVarP(&v, "name", "n", "", "account name") - _, _, err := ExecuteCmd(cmd, "--name", "a") + _, err := ExecuteCmd(cmd, "--name", "a") require.NoError(t, err) require.False(t, nothingToDo) } @@ -226,7 +226,7 @@ func TestActionMessage(t *testing.T) { }, } - out, _, err := ExecuteCmd(cmd) + out, err := ExecuteCmd(cmd) require.NoError(t, err) - require.Contains(t, "This is a test message", out) + require.Contains(t, out.Out, "this is a test message") } diff --git a/cmd/addaccount_test.go b/cmd/addaccount_test.go index eb419368..eaf805e7 100644 --- a/cmd/addaccount_test.go +++ b/cmd/addaccount_test.go @@ -23,9 +23,8 @@ import ( "github.com/nats-io/jwt/v2" "github.com/nats-io/nkeys" - "github.com/stretchr/testify/require" - "github.com/nats-io/nsc/v2/cmd/store" + "github.com/stretchr/testify/require" ) func Test_AddAccount(t *testing.T) { @@ -41,11 +40,11 @@ func Test_AddAccount(t *testing.T) { tests := CmdTests{ {CreateAddAccountCmd(), []string{"add", "account"}, nil, []string{"account name is required"}, true}, - {CreateAddAccountCmd(), []string{"add", "account", "--name", "A"}, nil, []string{"generated and stored account key", "added account"}, false}, + {CreateAddAccountCmd(), []string{"add", "account", "--name", "A"}, []string{"generated and stored account key", "added account"}, nil, false}, {CreateAddAccountCmd(), []string{"add", "account", "--name", "A"}, nil, []string{"the account \"A\" already exists"}, true}, {CreateAddAccountCmd(), []string{"add", "account", "--name", "B", "--public-key", bar}, nil, nil, false}, - {CreateAddAccountCmd(), []string{"add", "account", "--name", "*"}, nil, []string{"generated and stored account key", "added account"}, false}, - {CreateAddAccountCmd(), []string{"add", "account", "--name", "*"}, nil, []string{"generated and stored account key", "added account"}, false}, // should make a new name + {CreateAddAccountCmd(), []string{"add", "account", "--name", "*"}, []string{"generated and stored account key", "added account"}, nil, false}, + {CreateAddAccountCmd(), []string{"add", "account", "--name", "*"}, []string{"generated and stored account key", "added account"}, nil, false}, // should make a new name {CreateAddAccountCmd(), []string{"add", "account", "--name", "X", "--public-key", cpk}, nil, []string{"specified key is not a valid account nkey"}, true}, {CreateAddAccountCmd(), []string{"add", "account", "--name", "badexp", "--expiry", "30d"}, nil, nil, false}, } @@ -56,7 +55,7 @@ func Test_AddAccount(t *testing.T) { func Test_AddAccountNoStore(t *testing.T) { // reset the store require.NoError(t, ForceStoreRoot(t, "")) - _, _, err := ExecuteCmd(CreateAddAccountCmd()) + _, err := ExecuteCmd(CreateAddAccountCmd()) require.NotNil(t, err) require.Equal(t, "no stores available", err.Error()) } @@ -65,7 +64,7 @@ func Test_AddAccountValidateOutput(t *testing.T) { ts := NewTestStore(t, "test") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "A", "--start", "2018-01-01", "--expiry", "2050-01-01") + _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "A", "--start", "2018-01-01", "--expiry", "2050-01-01") require.NoError(t, err) validateAddAccountClaims(t, ts) ts.List(t) @@ -79,7 +78,7 @@ func Test_AddAccountInteractive(t *testing.T) { cmd := CreateAddAccountCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, inputs) + _, err := ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) validateAddAccountClaims(t, ts) } @@ -124,7 +123,7 @@ func Test_AddAccountManagedStore(t *testing.T) { ts := NewTestStoreWithOperatorJWT(t, string(m["operator"])) defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "A", "--start", "2018-01-01", "--expiry", "2050-01-01") + _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "A", "--start", "2018-01-01", "--expiry", "2050-01-01") require.NoError(t, err) } @@ -140,13 +139,13 @@ func Test_AddAccountManagedStoreWithSigningKey(t *testing.T) { token, err := oc.Encode(kp) require.NoError(t, err) tf := filepath.Join(ts.Dir, "O.jwt") - err = Write(tf, []byte(token)) + err = WriteFile(tf, []byte(token)) require.NoError(t, err) - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", tf) + _, err = ExecuteCmd(createAddOperatorCmd(), "--url", tf) require.NoError(t, err) // sign with the signing key inputs := []interface{}{"A", true, "0", "0", 0, string(s1)} - _, _, err = ExecuteInteractiveCmd(HoistRootFlags(CreateAddAccountCmd()), inputs) + _, err = ExecuteInteractiveCmd(HoistRootFlags(CreateAddAccountCmd()), inputs) require.NoError(t, err) accJWT, err := os.ReadFile(filepath.Join(ts.StoreDir, "O", "accounts", "A", "A.jwt")) require.NoError(t, err) @@ -157,7 +156,7 @@ func Test_AddAccountManagedStoreWithSigningKey(t *testing.T) { require.True(t, oc.DidSign(ac)) // sign with the account key inputs = []interface{}{"B", true, "0", "0", 1, string(s1)} - _, _, err = ExecuteInteractiveCmd(HoistRootFlags(CreateAddAccountCmd()), inputs) + _, err = ExecuteInteractiveCmd(HoistRootFlags(CreateAddAccountCmd()), inputs) require.NoError(t, err) accJWT, err = os.ReadFile(filepath.Join(ts.StoreDir, "O", "accounts", "B", "B.jwt")) require.NoError(t, err) @@ -172,12 +171,12 @@ func Test_AddAccountInteractiveSigningKey(t *testing.T) { defer ts.Done(t) s1, pk1, _ := CreateOperatorKey(t) - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--sk", pk1) + _, err := ExecuteCmd(createEditOperatorCmd(), "--sk", pk1) require.NoError(t, err) // sign with the custom key inputs := []interface{}{"A", true, "0", "0", 1, string(s1)} - _, _, err = ExecuteInteractiveCmd(HoistRootFlags(CreateAddAccountCmd()), inputs) + _, err = ExecuteInteractiveCmd(HoistRootFlags(CreateAddAccountCmd()), inputs, []string{}...) require.NoError(t, err) d, err := ts.Store.Read(store.JwtName("O")) @@ -196,7 +195,7 @@ func Test_AddAccountNameArg(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(HoistRootFlags(CreateAddAccountCmd()), "A") + _, err := ExecuteCmd(HoistRootFlags(CreateAddAccountCmd()), "A") require.NoError(t, err) _, err = ts.Store.ReadAccountClaim("A") @@ -214,7 +213,7 @@ func Test_AddAccountWithExistingKey(t *testing.T) { pk, err := kp.PublicKey() require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "A", "--public-key", pk) + _, err = ExecuteCmd(CreateAddAccountCmd(), "A", "--public-key", pk) require.NoError(t, err) } @@ -232,7 +231,7 @@ func Test_AddManagedAccountWithExistingKey(t *testing.T) { pk, err := kp.PublicKey() require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "A", "--public-key", pk) + _, err = ExecuteCmd(CreateAddAccountCmd(), "A", "--public-key", pk) require.NoError(t, err) // inspect the pushed JWT before it was resigned @@ -254,7 +253,7 @@ func Test_AddAccountWithSigningKeyOnly(t *testing.T) { require.NoError(t, err) require.True(t, ts.KeyStore.HasPrivateKey(pk)) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--sk", pk) + _, err = ExecuteCmd(createEditOperatorCmd(), "--sk", pk) require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -262,7 +261,7 @@ func Test_AddAccountWithSigningKeyOnly(t *testing.T) { require.NoError(t, ts.KeyStore.Remove(oc.Subject)) require.False(t, ts.KeyStore.HasPrivateKey(oc.Subject)) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "A") + _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "A") require.NoError(t, err) _, err = ts.Store.ReadAccountClaim("A") @@ -273,7 +272,7 @@ func Test_AddAccount_Pubs(t *testing.T) { ts := NewTestStore(t, "edit user") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "-n", "A", "--allow-pub", "a,b", "--allow-pubsub", "c", "--deny-pub", "foo", "--deny-pubsub", "bar") + _, err := ExecuteCmd(CreateAddAccountCmd(), "-n", "A", "--allow-pub", "a,b", "--allow-pubsub", "c", "--deny-pub", "foo", "--deny-pubsub", "bar") require.NoError(t, err) cc, err := ts.Store.ReadAccountClaim("A") @@ -289,7 +288,7 @@ func Test_AddAccountBadName(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "A/B") + _, err := ExecuteCmd(CreateAddAccountCmd(), "A/B") require.Error(t, err) require.Contains(t, err.Error(), "name cannot contain '/' or '\\'") } diff --git a/cmd/addexport_test.go b/cmd/addexport_test.go index a66e9c80..c6e1ab7b 100644 --- a/cmd/addexport_test.go +++ b/cmd/addexport_test.go @@ -31,16 +31,16 @@ func Test_AddExport(t *testing.T) { tests := CmdTests{ {createAddExportCmd(), []string{"add", "export"}, nil, []string{"subject is required"}, true}, - {createAddExportCmd(), []string{"add", "export", "--subject", "foo"}, nil, []string{"added public stream export \"foo\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "bar", "--service"}, nil, []string{"added public service export \"bar\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "bar"}, nil, []string{"added public stream export \"bar\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "foo", "--service"}, nil, []string{"added public service export \"foo\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "baz.>"}, nil, []string{"added public stream export \"baz.>\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "ar", "--name", "mar"}, nil, []string{"added public stream export \"mar\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "mar", "--name", "ar", "--service"}, nil, []string{"added public service export \"ar\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "pubstream", "--private"}, nil, []string{"added private stream export \"pubstream\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "pubservice", "--private", "--service"}, nil, []string{"added private service export \"pubservice\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "th.1", "--service", "--response-threshold", "1s"}, nil, []string{"added public service export \"th.1\""}, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "foo"}, []string{"added public stream export \"foo\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "bar", "--service"}, []string{"added public service export \"bar\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "bar"}, []string{"added public stream export \"bar\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "foo", "--service"}, []string{"added public service export \"foo\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "baz.>"}, []string{"added public stream export \"baz.>\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "ar", "--name", "mar"}, []string{"added public stream export \"mar\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "mar", "--name", "ar", "--service"}, []string{"added public service export \"ar\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "pubstream", "--private"}, []string{"added private stream export \"pubstream\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "pubservice", "--private", "--service"}, []string{"added private service export \"pubservice\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "th.1", "--service", "--response-threshold", "1s"}, []string{"added public service export \"th.1\""}, nil, false}, {createAddExportCmd(), []string{"add", "export", "--subject", "th.2", "--response-threshold", "1whatever"}, nil, []string{`time: unknown unit`}, true}, {createAddExportCmd(), []string{"add", "export", "--subject", "re", "--response-type", "stream"}, nil, []string{"response type can only be specified in conjunction with service"}, true}, } @@ -54,11 +54,11 @@ func Test_AddPublicExport(t *testing.T) { ts.AddAccount(t, "A") tests := CmdTests{ - {createAddExportCmd(), []string{"add", "export", "--private=false", "--subject", "hello"}, nil, []string{"added public stream export \"hello\""}, false}, + {createAddExportCmd(), []string{"add", "export", "--private=false", "--subject", "hello"}, []string{"added public stream export \"hello\""}, nil, false}, {createAddExportCmd(), []string{"add", "export", "--private=false", "--subject", "hello", "--account-token-position", "1"}, nil, []string{"Account Token Position can only be used with wildcard subjects"}, true}, {createAddExportCmd(), []string{"add", "export", "--private=false", "--subject", "*.hello", "--account-token-position", "2"}, nil, []string{"Account Token Position 2 matches 'hello' but must match a *"}, true}, {createAddExportCmd(), []string{"add", "export", "--private=false", "--subject", "*.hello", "--account-token-position", "3"}, nil, []string{"Account Token Position 3 exceeds length of subject"}, true}, - {createAddExportCmd(), []string{"add", "export", "--private=false", "--subject", "*.hello", "--account-token-position", "1"}, nil, []string{" added public stream export \"*.hello\""}, false}, + {createAddExportCmd(), []string{"add", "export", "--private=false", "--subject", "*.hello", "--account-token-position", "1"}, []string{" added public stream export \"*.hello\""}, nil, false}, } tests.Run(t, "root", "add") } @@ -70,10 +70,10 @@ func Test_AddExportVerify(t *testing.T) { ts.AddAccount(t, "A") tests := CmdTests{ - {createAddExportCmd(), []string{"add", "export", "--subject", "pubfoo"}, nil, []string{"added public stream export \"pubfoo\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "privfoo", "--private"}, nil, []string{"added private stream export \"privfoo\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "pubbar", "--service"}, nil, []string{"added public service export \"pubbar\""}, false}, - {createAddExportCmd(), []string{"add", "export", "--subject", "privbar", "--service", "--private"}, nil, []string{"added private service export \"privbar\""}, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "pubfoo"}, []string{"added public stream export \"pubfoo\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "privfoo", "--private"}, []string{"added private stream export \"privfoo\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "pubbar", "--service"}, []string{"added public service export \"pubbar\""}, nil, false}, + {createAddExportCmd(), []string{"add", "export", "--subject", "privbar", "--service", "--private"}, []string{"added private service export \"privbar\""}, nil, false}, } tests.Run(t, "root", "add") validateAddExports(t, ts) @@ -122,7 +122,7 @@ func Test_AddExportManagedStore(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createAddExportCmd(), "--subject", "aaaa") + _, err := ExecuteCmd(createAddExportCmd(), []string{"--subject", "aaaa"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -143,7 +143,7 @@ func Test_AddExportAccountNameRequired(t *testing.T) { ts.AddAccount(t, "B") t.Log("B", ts.GetAccountPublicKey(t, "B")) - _, _, err := ExecuteCmd(createAddExportCmd(), "--subject", "bbbb") + _, err := ExecuteCmd(createAddExportCmd(), []string{"--subject", "bbbb"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -162,7 +162,7 @@ func TestAddStreamExportInteractive(t *testing.T) { input := []interface{}{0, 0, "foo.>", "Foo Stream", false, 0} cmd := createAddExportCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, input, "-i") + _, err := ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -183,7 +183,7 @@ func TestAddServiceExportInteractive(t *testing.T) { input := []interface{}{0, 1, "bar.>", "Bar Stream", true, true, "header", "foo", 0, "1s", true, 0} cmd := createAddExportCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, input, "-i") + _, err := ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -206,7 +206,7 @@ func TestAddExportNonInteractive(t *testing.T) { cmd := createAddExportCmd() HoistRootFlags(cmd) - _, _, err := ExecuteCmd(cmd, "--service", "--name", "q", "--subject", "q", "--response-type", jwt.ResponseTypeChunked) + _, err := ExecuteCmd(cmd, []string{"--service", "--name", "q", "--subject", "q", "--response-type", jwt.ResponseTypeChunked}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -225,7 +225,7 @@ func TestAddServiceLatency(t *testing.T) { ts.AddAccount(t, "A") cmd := createAddExportCmd() - _, _, err := ExecuteCmd(cmd, "--service", "--subject", "q", "--latency", "q.lat", "--sampling", "100", "--response-type", jwt.ResponseTypeStream) + _, err := ExecuteCmd(cmd, []string{"--service", "--subject", "q", "--latency", "q.lat", "--sampling", "100", "--response-type", jwt.ResponseTypeStream}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -245,7 +245,7 @@ func Test_AddExportBadResponseType(t *testing.T) { ts.AddAccount(t, "A") cmd := createAddExportCmd() - _, _, err := ExecuteCmd(cmd, "--service", "--subject", "q", "--response-type", "foo") + _, err := ExecuteCmd(cmd, []string{"--service", "--subject", "q", "--response-type", "foo"}...) require.Error(t, err) require.Contains(t, err.Error(), "invalid response type") } @@ -259,7 +259,7 @@ func TestAddServiceLatencyInteractive(t *testing.T) { // service, subject, name, private, track, freq args := []interface{}{1, "q", "q", false, true, "100", "q.lat", 1, "0", true} - _, _, err := ExecuteInteractiveCmd(cmd, args) + _, err := ExecuteInteractiveCmd(cmd, args) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -279,7 +279,7 @@ func TestAddServiceExportWTracing(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createAddExportCmd(), "--service", "--subject", "q", "--allow-trace") + _, err := ExecuteCmd(createAddExportCmd(), []string{"--service", "--subject", "q", "--allow-trace"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -292,6 +292,6 @@ func TestAddStreamExportWTracing(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createAddExportCmd(), "--subject", "q", "--allow-trace") + _, err := ExecuteCmd(createAddExportCmd(), []string{"--subject", "q", "--allow-trace"}...) require.Error(t, err) } diff --git a/cmd/addimport_test.go b/cmd/addimport_test.go index a79670eb..ebfa0b74 100644 --- a/cmd/addimport_test.go +++ b/cmd/addimport_test.go @@ -38,11 +38,11 @@ func Test_AddImport(t *testing.T) { token := ts.GenerateActivation(t, "A", "foobar.>", "B") fp := filepath.Join(ts.Dir, "token.jwt") - require.NoError(t, Write(fp, []byte(token))) + require.NoError(t, WriteFile(fp, []byte(token))) tests := CmdTests{ //{createAddImportCmd(), []string{"add", "import", "--account", "B"}, nil, []string{"token is required"}, true}, - {createAddImportCmd(), []string{"add", "import", "--account", "B", "--token", fp}, nil, []string{"added stream import"}, false}, + {createAddImportCmd(), []string{"add", "import", "--account", "B", "--token", fp}, []string{"added stream import"}, nil, false}, } tests.Run(t, "root", "add") @@ -65,9 +65,9 @@ func Test_AddImportSelfImportsRejected(t *testing.T) { token := ts.GenerateActivation(t, "A", "foobar.>", "A") fp := filepath.Join(ts.Dir, "token.jwt") - require.NoError(t, Write(fp, []byte(token))) + require.NoError(t, WriteFile(fp, []byte(token))) - _, _, err := ExecuteCmd(createAddImportCmd(), "--token", fp) + _, err := ExecuteCmd(createAddImportCmd(), []string{"--token", fp}...) require.Error(t, err) require.Equal(t, "export issuer is this account", err.Error()) } @@ -88,7 +88,7 @@ func Test_AddImportFromURL(t *testing.T) { })) defer ht.Close() - _, _, err := ExecuteCmd(createAddImportCmd(), "--account", "B", "--token", ht.URL) + _, err := ExecuteCmd(createAddImportCmd(), []string{"--account", "B", "--token", ht.URL}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -113,13 +113,13 @@ func Test_AddImportInteractive(t *testing.T) { token := ts.GenerateActivation(t, "A", "foobar.>", "B") fp := filepath.Join(ts.Dir, "token.jwt") - require.NoError(t, Write(fp, []byte(token))) + require.NoError(t, WriteFile(fp, []byte(token))) cmd := createAddImportCmd() HoistRootFlags(cmd) input := []interface{}{1, false, false, fp, "my import", "barfoo.>", false, 0} - _, _, err = ExecuteInteractiveCmd(cmd, input, "-i") + _, err = ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -148,7 +148,7 @@ func Test_AddImportGeneratingTokenInteractive(t *testing.T) { cmd := createAddImportCmd() HoistRootFlags(cmd) input := []interface{}{1, true, 1, "my import", "barfoo.>", true, 0} - _, _, err = ExecuteInteractiveCmd(cmd, input) + _, err = ExecuteInteractiveCmd(cmd, input) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -178,7 +178,7 @@ func Test_AddServiceImportGeneratingTokenInteractive(t *testing.T) { cmd := createAddImportCmd() HoistRootFlags(cmd) input := []interface{}{1, true, 1, "barfoo.>", true, "my import", "foobar.>"} - _, _, err = ExecuteInteractiveCmd(cmd, input) + _, err = ExecuteInteractiveCmd(cmd, input) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -199,7 +199,7 @@ func Test_AddPublicImport(t *testing.T) { ts.AddExport(t, "A", jwt.Stream, "foobar.>", 0, true) ts.AddAccount(t, "B") - _, _, err := ExecuteCmd(createAddImportCmd(), "--account", "B", "--src-account", "A", "--remote-subject", "foobar.>") + _, err := ExecuteCmd(createAddImportCmd(), []string{"--account", "B", "--src-account", "A", "--remote-subject", "foobar.>"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -212,7 +212,7 @@ func Test_AddImport_TokenAndPublic(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createAddImportCmd(), "--token", "/foo", "--remote-subject", "foobar.>") + _, err := ExecuteCmd(createAddImportCmd(), []string{"--token", "/foo", "--remote-subject", "foobar.>"}...) require.Error(t, err) require.Contains(t, err.Error(), "private imports require src-account") } @@ -222,7 +222,7 @@ func Test_AddImport_MoreForPublic(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createAddImportCmd(), "--remote-subject", "foobar.>") + _, err := ExecuteCmd(createAddImportCmd(), []string{"--remote-subject", "foobar.>"}...) require.Error(t, err) require.Contains(t, err.Error(), "public imports require src-account, remote-subject") } @@ -245,7 +245,7 @@ func Test_AddImport_PublicInteractive(t *testing.T) { HoistRootFlags(cmd) // B, public, A's pubkey, local sub, service, name test, remote subj "test.foobar.alberto, key input := []interface{}{1, false, true, apub, "foobar.x.*", true, "test", "test.foobar.alberto.*", 0} - _, _, err = ExecuteInteractiveCmd(cmd, input, "-i") + _, err = ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -278,7 +278,7 @@ func Test_AddImport_PublicImportsInteractive(t *testing.T) { HoistRootFlags(cmd) // B, don't pick, public, A's pubkey, remote sub, stream, name, local subj "test.foobar.>, allow-tracing, key input := []interface{}{1, false, true, apub, "foobar.>", false, "test", "test.foobar.>", true, 0} - _, _, err = ExecuteInteractiveCmd(cmd, input) + _, err = ExecuteInteractiveCmd(cmd, input) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -293,7 +293,7 @@ func Test_AddImport_PublicImportsInteractive(t *testing.T) { // B, don't pick, public, A's pubkey, remote sub, service, name test, local subj "test.foobar.>, key input = []interface{}{1, false, true, apub, "q.*", true, "q", "qq.*", 0} - _, _, err = ExecuteInteractiveCmd(cmd, input) + _, err = ExecuteInteractiveCmd(cmd, input) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("B") @@ -312,14 +312,14 @@ func Test_AddImportWithSigningKeyToken(t *testing.T) { _, pk, sk := CreateAccountKey(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--sk", pk) + _, err := ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) ts.AddExport(t, "A", jwt.Stream, "foobar.>", 0, false) ts.AddAccount(t, "B") token := ts.GenerateActivationWithSigner(t, "A", "foobar.>", "B", sk) tp := filepath.Join(ts.Dir, "token.jwt") - require.NoError(t, Write(tp, []byte(token))) + require.NoError(t, WriteFile(tp, []byte(token))) bc, err := ts.Store.ReadAccountClaim("B") require.NoError(t, err) @@ -335,7 +335,7 @@ func Test_AddImportWithSigningKeyToken(t *testing.T) { // account to import is B require.Equal(t, acc.Subject, bc.Subject) - _, _, err = ExecuteCmd(createAddImportCmd(), "--account", "B", "--token", tp) + _, err = ExecuteCmd(createAddImportCmd(), []string{"--account", "B", "--token", tp}...) require.NoError(t, err) acb, err := ts.Store.ReadAccountClaim("B") require.NoError(t, err) @@ -349,7 +349,7 @@ func Test_AddDecoratedToken(t *testing.T) { _, pk, sk := CreateAccountKey(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--sk", pk) + _, err := ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) ts.AddExport(t, "A", jwt.Stream, "foobar.>", 0, false) @@ -359,9 +359,9 @@ func Test_AddDecoratedToken(t *testing.T) { require.NoError(t, err) token = string(d) tp := filepath.Join(ts.Dir, "token.jwt") - require.NoError(t, Write(tp, []byte(token))) + require.NoError(t, WriteFile(tp, []byte(token))) - _, _, err = ExecuteCmd(createAddImportCmd(), "--account", "B", "--token", tp) + _, err = ExecuteCmd(createAddImportCmd(), []string{"--account", "B", "--token", tp}...) require.NoError(t, err) acb, err := ts.Store.ReadAccountClaim("B") require.NoError(t, err) @@ -389,7 +389,7 @@ func Test_AddImport_LocalImportsInteractive(t *testing.T) { // B, pick, stream foobar, name test, local subj "test.foobar.>, key input := []interface{}{1, true, 1, "test", "test.foobar.>", true} - _, _, err = ExecuteInteractiveCmd(cmd, input) + _, err = ExecuteInteractiveCmd(cmd, input) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -405,7 +405,7 @@ func Test_AddImport_LocalImportsInteractive(t *testing.T) { // B, pick, service q, name q service, local subj qq input = []interface{}{1, true, 2, true, "q service", "qq", 0} - _, _, err = ExecuteInteractiveCmd(cmd, input) + _, err = ExecuteInteractiveCmd(cmd, input) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("B") @@ -433,8 +433,8 @@ func Test_ImportStreamHandlesDecorations(t *testing.T) { require.NoError(t, err) ap := filepath.Join(ts.Dir, "activation.jwt") - Write(ap, d) - _, _, err = ExecuteCmd(createAddImportCmd(), "--account", "B", "--token", ap) + require.NoError(t, WriteFile(ap, d)) + _, err = ExecuteCmd(createAddImportCmd(), []string{"--account", "B", "--token", ap}...) require.NoError(t, err) bc, err := ts.Store.ReadAccountClaim("B") @@ -457,8 +457,8 @@ func Test_ImportServiceHandlesDecorations(t *testing.T) { require.NoError(t, err) ap := filepath.Join(ts.Dir, "activation.jwt") - Write(ap, d) - _, _, err = ExecuteCmd(createAddImportCmd(), "--account", "B", "--token", ap) + require.NoError(t, WriteFile(ap, d)) + _, err = ExecuteCmd(createAddImportCmd(), []string{"--account", "B", "--token", ap}...) require.NoError(t, err) bc, err := ts.Store.ReadAccountClaim("B") @@ -476,7 +476,7 @@ func Test_AddImportToAccount(t *testing.T) { bpk := ts.GetAccountPublicKey(t, "B") - _, _, err := ExecuteCmd(createAddImportCmd(), "--account", "A", "--src-account", bpk, "--remote-subject", "s.>") + _, err := ExecuteCmd(createAddImportCmd(), []string{"--account", "A", "--src-account", bpk, "--remote-subject", "s.>"}...) require.NoError(t, err) bc, err := ts.Store.ReadAccountClaim("A") @@ -499,23 +499,23 @@ func Test_AddWilcdardImport(t *testing.T) { srvcToken := ts.GenerateActivation(t, "A", "priv-srvc.>", "B") srvcFp := filepath.Join(ts.Dir, "srvc-token.jwt") - require.NoError(t, Write(srvcFp, []byte(srvcToken))) + require.NoError(t, WriteFile(srvcFp, []byte(srvcToken))) defer os.Remove(srvcFp) strmToken := ts.GenerateActivation(t, "A", "priv-strm.>", "B") strmFp := filepath.Join(ts.Dir, "strm-token.jwt") - require.NoError(t, Write(strmFp, []byte(strmToken))) + require.NoError(t, WriteFile(strmFp, []byte(strmToken))) defer os.Remove(strmFp) tests := CmdTests{ - {createAddImportCmd(), []string{"add", "import", "--account", "B", "--token", srvcFp}, nil, - []string{"added service import"}, false}, - {createAddImportCmd(), []string{"add", "import", "--account", "B", "--token", strmFp}, nil, - []string{"added stream import"}, false}, + {createAddImportCmd(), []string{"add", "import", "--account", "B", "--token", srvcFp}, + []string{"added service import"}, nil, false}, + {createAddImportCmd(), []string{"add", "import", "--account", "B", "--token", strmFp}, + []string{"added stream import"}, nil, false}, {createAddImportCmd(), []string{"add", "import", "--account", "B", "--src-account", aPub, "--service", - "--remote-subject", "pub-srvc.>"}, nil, []string{"added service import"}, false}, + "--remote-subject", "pub-srvc.>"}, []string{"added service import"}, nil, false}, {createAddImportCmd(), []string{"add", "import", "--account", "B", "--src-account", aPub, - "--remote-subject", "pub-strm.>"}, nil, []string{"added stream import"}, false}, + "--remote-subject", "pub-strm.>"}, []string{"added stream import"}, nil, false}, } tests.Run(t, "root", "add") @@ -534,7 +534,7 @@ func TestAddImport_SameName(t *testing.T) { // account, locally available, name, local subj, // database, true, A: -> stream.database, "stream.database", "ingest input := []interface{}{2, true, 1, "ingest.a", "ingest.a", true} - _, _, err := ExecuteInteractiveCmd(createAddImportCmd(), input) + _, err := ExecuteInteractiveCmd(createAddImportCmd(), input) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("database") @@ -547,7 +547,7 @@ func TestAddImport_SameName(t *testing.T) { require.Equal(t, ts.GetAccountPublicKey(t, "A"), ac.Imports[0].Account) input = []interface{}{2, true, 3, "ingest.b", "ingest.b", true} - _, _, err = ExecuteInteractiveCmd(createAddImportCmd(), input) + _, err = ExecuteInteractiveCmd(createAddImportCmd(), input) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("database") diff --git a/cmd/addmapping_test.go b/cmd/addmapping_test.go index 9742256b..a8485b9e 100644 --- a/cmd/addmapping_test.go +++ b/cmd/addmapping_test.go @@ -13,11 +13,11 @@ func Test_AddMappingCannotExceed100(t *testing.T) { ts.AddAccount(t, "A") // add a default mapping at a 100, default mapping at max - _, _, err := ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qq", "--weight", "100") + _, err := ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qq", "--weight", "100"}...) require.NoError(t, err) // default mapping cannot be incremented - _, _, err = ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qqq", "--weight", "10") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qqq", "--weight", "10"}...) require.Error(t, err) require.ErrorContains(t, err, "Mapping \"q\" exceeds 100%") @@ -33,14 +33,14 @@ func Test_AddMappingCannotExceed100(t *testing.T) { }, mappings[0]) // can add another mapping but has to be for cluster - _, _, err = ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qa", "--weight", "100", "--cluster", "A") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qa", "--weight", "100", "--cluster", "A"}...) require.NoError(t, err) // and for another cluster - _, _, err = ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qb", "--weight", "100", "--cluster", "B") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qb", "--weight", "100", "--cluster", "B"}...) require.NoError(t, err) // incrementing one of the above maxed clusters fails - _, _, err = ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qaa", "--weight", "10", "--cluster", "A") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qaa", "--weight", "10", "--cluster", "A"}...) require.Error(t, err) require.ErrorContains(t, err, "Mapping \"q\" in cluster \"A\" exceeds 100%") } @@ -51,7 +51,7 @@ func Test_AddMappingCrud(t *testing.T) { ts.AddAccount(t, "A") // add a default mapping at a 100, default mapping at max - _, _, err := ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qq", "--weight", "100") + _, err := ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qq", "--weight", "100"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -66,7 +66,7 @@ func Test_AddMappingCrud(t *testing.T) { ts.AddAccount(t, "B") // add a default mapping at a 100, default mapping at max - _, _, err = ExecuteCmd(createAddMappingCmd(), "--from", "qq", "--to", "rr", "--weight", "100", "--cluster", "B") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--from", "qq", "--to", "rr", "--weight", "100", "--cluster", "B"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("B") diff --git a/cmd/addoperator_test.go b/cmd/addoperator_test.go index a35634fb..df8b26a6 100644 --- a/cmd/addoperator_test.go +++ b/cmd/addoperator_test.go @@ -41,7 +41,7 @@ func Test_AddOperator(t *testing.T) { t.Fatal(err) } - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--name", "O", "--sys", "--generate-signing-key") + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--name", "O", "--sys", "--generate-signing-key"}...) require.NoError(t, err) require.FileExists(t, filepath.Join(ts.StoreDir, "O", ".nsc")) @@ -61,10 +61,9 @@ func TestImportOperator(t *testing.T) { token, err := oc.Encode(kp) require.NoError(t, err) tf := filepath.Join(ts.Dir, "O.jwt") - err = Write(tf, []byte(token)) - require.NoError(t, err) + require.NoError(t, WriteFile(tf, []byte(token))) - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", tf) + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--url", tf}...) require.NoError(t, err) storeFile := filepath.Join(ts.StoreDir, "O", ".nsc") require.FileExists(t, storeFile) @@ -85,10 +84,10 @@ func TestImportOperator(t *testing.T) { } check() - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", tf) + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--url", tf}...) require.Error(t, err) - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", tf, "--force") + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--url", tf, "--force"}...) require.NoError(t, err) check() @@ -98,7 +97,7 @@ func TestAddOperatorInteractive(t *testing.T) { ts := NewEmptyStore(t) defer ts.Done(t) - _, _, err := ExecuteInteractiveCmd(createAddOperatorCmd(), []interface{}{false, "O", "2019-12-01", "2029-12-01", true, true, true}) + _, err := ExecuteInteractiveCmd(createAddOperatorCmd(), []interface{}{false, "O", "2019-12-01", "2029-12-01", true, true, true}) require.NoError(t, err) d, err := Read(filepath.Join(ts.StoreDir, "O", "O.jwt")) require.NoError(t, err) @@ -145,10 +144,9 @@ func TestImportOperatorInteractive(t *testing.T) { token, err := oc.Encode(kp) require.NoError(t, err) tf := filepath.Join(ts.Dir, "O.jwt") - err = Write(tf, []byte(token)) - require.NoError(t, err) + require.NoError(t, WriteFile(tf, []byte(token))) - _, _, err = ExecuteInteractiveCmd(createAddOperatorCmd(), []interface{}{true, tf}) + _, err = ExecuteInteractiveCmd(createAddOperatorCmd(), []interface{}{true, tf}) require.NoError(t, err) target := filepath.Join(ts.StoreDir, "O", "O.jwt") @@ -177,7 +175,7 @@ func Test_ImportOperatorFromURL(t *testing.T) { u, err := url.Parse(hts.URL) require.NoError(t, err) u.Path = fmt.Sprintf("/jwt/v1/operators/%s", pub) - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", u.String()) + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--url", u.String()}...) require.NoError(t, err) ts.SwitchOperator(t, "O") @@ -194,7 +192,7 @@ func Test_AddOperatorWithKey(t *testing.T) { seed, pub, _ := CreateOperatorKey(t) cmd := createAddOperatorCmd() HoistRootFlags(cmd) - _, _, err := ExecuteCmd(cmd, "--name", "T", "-K", string(seed)) + _, err := ExecuteCmd(cmd, []string{"--name", "T", "-K", string(seed)}...) require.NoError(t, err) ts.SwitchOperator(t, "T") @@ -213,7 +211,7 @@ func Test_AddOperatorWithKeyInteractive(t *testing.T) { HoistRootFlags(cmd) args := []interface{}{false, "T", "0", "0", false, false, false, string(seed)} - _, _, err := ExecuteInteractiveCmd(cmd, args) + _, err := ExecuteInteractiveCmd(cmd, args) require.NoError(t, err) ts.SwitchOperator(t, "T") @@ -245,7 +243,7 @@ func Test_AddWellKnownOperator(t *testing.T) { wellKnownOperators = ops // add the well known operator - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", "T") + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--url", "T"}...) require.NoError(t, err) ts.SwitchOperator(t, "T") @@ -259,7 +257,7 @@ func Test_AddNotWellKnownOperator(t *testing.T) { defer ts.Done(t) // add the well known operator - _, _, err := ExecuteCmd(createAddOperatorCmd(), "--url", "X") + _, err := ExecuteCmd(createAddOperatorCmd(), []string{"--url", "X"}...) require.Error(t, err) } @@ -267,7 +265,7 @@ func Test_AddOperatorNameArg(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(HoistRootFlags(createAddOperatorCmd()), "X") + _, err := ExecuteCmd(HoistRootFlags(createAddOperatorCmd()), []string{"X"}...) require.NoError(t, err) ts.SwitchOperator(t, "X") @@ -286,12 +284,11 @@ func TestImportOperatorV2(t *testing.T) { token, err := oc.Encode(kp) require.NoError(t, err) tf := filepath.Join(ts.Dir, "O.jwt") - err = Write(tf, []byte(token)) - require.NoError(t, err) + require.NoError(t, WriteFile(tf, []byte(token))) - _, stdErr, err := ExecuteCmd(createAddOperatorCmd(), "--url", tf) + out, err := ExecuteCmd(createAddOperatorCmd(), []string{"--url", tf}...) require.Error(t, err) - require.Contains(t, stdErr, JWTUpgradeBannerJWT(1).Error()) + require.Contains(t, out.Err, JWTUpgradeBannerJWT(1).Error()) } func TestImportReIssuedOperator(t *testing.T) { @@ -312,9 +309,8 @@ func TestImportReIssuedOperator(t *testing.T) { token, err := oc.Encode(kpOld) require.NoError(t, err) tf := filepath.Join(ts.Dir, "Oold.jwt") - err = Write(tf, []byte(token)) - require.NoError(t, err) - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", tf) + require.NoError(t, WriteFile(tf, []byte(token))) + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--url", tf}...) require.NoError(t, err) checkOp(pubOld) @@ -324,9 +320,8 @@ func TestImportReIssuedOperator(t *testing.T) { token, err = oc.Encode(kpNew) require.NoError(t, err) tf = filepath.Join(ts.Dir, "Onew.jwt") - err = Write(tf, []byte(token)) - require.NoError(t, err) - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", tf, "--force") + require.NoError(t, WriteFile(tf, []byte(token))) + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--url", tf, "--force"}...) require.NoError(t, err) checkOp(pubNew) } @@ -335,7 +330,7 @@ func Test_AddOperatorBadName(t *testing.T) { ts := NewEmptyStore(t) defer ts.Done(t) - _, _, err := ExecuteCmd(createAddOperatorCmd(), "A/B") + _, err := ExecuteCmd(createAddOperatorCmd(), []string{"A/B"}...) require.Error(t, err) require.Contains(t, err.Error(), "name cannot contain '/' or '\\'") } diff --git a/cmd/adduser_test.go b/cmd/adduser_test.go index 8d3313c9..83e867de 100644 --- a/cmd/adduser_test.go +++ b/cmd/adduser_test.go @@ -16,6 +16,7 @@ package cmd import ( + "github.com/nats-io/cliprompts/v2" "os" "path/filepath" "testing" @@ -30,7 +31,7 @@ func Test_AddUser(t *testing.T) { ts := NewTestStore(t, "add_server") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "c") + _, err := ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "c"}...) require.NoError(t, err) _, bar, _ := CreateUserKey(t) @@ -38,16 +39,16 @@ func Test_AddUser(t *testing.T) { tests := CmdTests{ {CreateAddUserCmd(), []string{"add", "user"}, nil, []string{"user name is required"}, true}, - {CreateAddUserCmd(), []string{"add", "user", "--name", "foo"}, nil, []string{"generated and stored user key", "added user"}, false}, + {CreateAddUserCmd(), []string{"add", "user", "--name", "foo"}, []string{"generated and stored user key", "added user"}, nil, false}, {CreateAddUserCmd(), []string{"add", "user", "--name", "foo"}, nil, []string{"the user \"foo\" already exists"}, true}, {CreateAddUserCmd(), []string{"add", "user", "--name", "foo"}, nil, []string{"the user \"foo\" already exists"}, true}, - {CreateAddUserCmd(), []string{"add", "user", "--name", "*"}, nil, []string{"generated and stored user key", "added user"}, false}, - {CreateAddUserCmd(), []string{"add", "user", "--name", "*"}, nil, []string{"generated and stored user key", "added user"}, false}, // should make a new name + {CreateAddUserCmd(), []string{"add", "user", "--name", "*"}, []string{"generated and stored user key", "added user"}, nil, false}, + {CreateAddUserCmd(), []string{"add", "user", "--name", "*"}, []string{"generated and stored user key", "added user"}, nil, false}, // should make a new name {CreateAddUserCmd(), []string{"add", "user", "--name", "bar", "--public-key", bar}, nil, nil, false}, {CreateAddUserCmd(), []string{"add", "user", "--name", "badbar", "--public-key", badBar}, nil, []string{"invalid user key"}, true}, {CreateAddUserCmd(), []string{"add", "user", "--name", "badexp", "--expiry", "30d"}, nil, nil, false}, - {CreateAddUserCmd(), []string{"add", "user", "--name", "usra", "--deny-sub", "foo queue"}, nil, []string{"added user"}, false}, - {CreateAddUserCmd(), []string{"add", "user", "--name", "usrb", "--allow-sub", "foo queue"}, nil, []string{"added user"}, false}, + {CreateAddUserCmd(), []string{"add", "user", "--name", "usra", "--deny-sub", "foo queue"}, []string{"added user"}, nil, false}, + {CreateAddUserCmd(), []string{"add", "user", "--name", "usrb", "--allow-sub", "foo queue"}, []string{"added user"}, nil, false}, {CreateAddUserCmd(), []string{"add", "user", "--name", "usrc", "--deny-pub", "foo queue"}, nil, []string{"contains illegal space"}, true}, {CreateAddUserCmd(), []string{"add", "user", "--name", "usrd", "--allow-pub", "foo queue"}, nil, []string{"contains illegal space"}, true}, {CreateAddUserCmd(), []string{"add", "user", "--name", "usre", "--deny-pubsub", "foo queue"}, nil, []string{"contains illegal space"}, true}, @@ -62,7 +63,7 @@ func Test_AddUser(t *testing.T) { func Test_AddUserNoStore(t *testing.T) { // reset the store require.NoError(t, ForceStoreRoot(t, "")) - _, _, err := ExecuteCmd(CreateAddUserCmd()) + _, err := ExecuteCmd(CreateAddUserCmd(), []string{}...) require.Error(t, err) require.Equal(t, "no stores available", err.Error()) } @@ -71,10 +72,10 @@ func Test_AddUserOutput(t *testing.T) { ts := NewTestStore(t, "test") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "A") + _, err := ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "A"}...) require.NoError(t, err, "account creation") - _, _, err = ExecuteCmd(CreateAddUserCmd(), "--name", "U", "--start", "2018-01-01", "--expiry", "2050-01-01") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"--name", "U", "--start", "2018-01-01", "--expiry", "2050-01-01"}...) require.NoError(t, err) validateAddUserClaims(t, ts) } @@ -83,14 +84,14 @@ func Test_AddUserInteractive(t *testing.T) { ts := NewTestStore(t, "test") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "A") + _, err := ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "A"}...) require.NoError(t, err, "account creation") inputs := []interface{}{"U", true, "2018-01-01", "2050-01-01", 0} cmd := CreateAddUserCmd() HoistRootFlags(cmd) - _, _, err = ExecuteInteractiveCmd(cmd, inputs) + _, err = ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) validateAddUserClaims(t, ts) @@ -133,10 +134,10 @@ func Test_AddUserManagedStore(t *testing.T) { ts := NewTestStoreWithOperatorJWT(t, string(m["operator"])) defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "A", "--start", "2018-01-01", "--expiry", "2050-01-01") + _, err := ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "A", "--start", "2018-01-01", "--expiry", "2050-01-01"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddUserCmd(), "--name", "U", "--start", "2018-01-01", "--expiry", "2050-01-01") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"--name", "U", "--start", "2018-01-01", "--expiry", "2050-01-01"}...) require.NoError(t, err) validateAddUserClaims(t, ts) @@ -153,7 +154,7 @@ func Test_AddUser_Account(t *testing.T) { err := config.SetAccount("A") require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddUserCmd(), "--name", "bb", "--account", "B") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"--name", "bb", "--account", "B"}...) require.NoError(t, err) u, err := ts.Store.ReadUserClaim("B", "bb") @@ -168,10 +169,10 @@ func Test_AddUser_WithSK(t *testing.T) { ts.AddAccount(t, "A") sk, pk, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAccount(), "--sk", pk) + _, err := ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "bb", "--account", "A", "-K", string(sk)) + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "bb", "--account", "A", "-K", string(sk)}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -185,25 +186,24 @@ func Test_AddUser_WithSK(t *testing.T) { } func Test_AddUser_InteractiveResp(t *testing.T) { - t.Skip("interactive resp permissions") ts := NewTestStore(t, "test") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "A") + _, err := ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "A"}...) require.NoError(t, err, "account creation") - inputs := []interface{}{"U", true, true, "100", "1000ms", "2018-01-01", "2050-01-01", 0} + inputs := []interface{}{"U", true, "2018-01-01", "2050-01-01"} + cliprompts.LogFn = t.Log cmd := CreateAddUserCmd() HoistRootFlags(cmd) - _, _, err = ExecuteInteractiveCmd(cmd, inputs) + _, err = ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) validateAddUserClaims(t, ts) up, err := ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) - require.NotNil(t, up.Resp) - require.Equal(t, 100, up.Resp.MaxMsgs) - require.Equal(t, time.Millisecond*1000, up.Resp.Expires) + require.Equal(t, time.Date(2018, 1, 1, 0, 0, 0, 0, time.UTC).Unix(), up.NotBefore) + require.Equal(t, time.Date(2050, 1, 1, 0, 0, 0, 0, time.UTC).Unix(), up.Expires) } func Test_AddUserNameArg(t *testing.T) { @@ -211,7 +211,7 @@ func Test_AddUserNameArg(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "U") + _, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"U"}...) require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "U") @@ -224,7 +224,7 @@ func Test_AddUserWithResponsePerms(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(CreateAddUserCmd(), "U", "--max-responses", "100", "--response-ttl", "2ms") + _, err := ExecuteCmd(CreateAddUserCmd(), []string{"U", "--max-responses", "100", "--response-ttl", "2ms"}...) require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "U") @@ -240,7 +240,7 @@ func Test_AddUserWithResponsePerms2(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(CreateAddUserCmd(), "U", "--allow-pub-response", "--response-ttl", "2ms") + _, err := ExecuteCmd(CreateAddUserCmd(), []string{"U", "--allow-pub-response", "--response-ttl", "2ms"}...) require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "U") @@ -261,7 +261,7 @@ func Test_AddUserWithInteractiveAccountCtx(t *testing.T) { inputs := []interface{}{1, "bb", true, "0", "0", 0} cmd := CreateAddUserCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, inputs) + _, err := ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) bpk := ts.GetAccountPublicKey(t, "B") @@ -272,7 +272,7 @@ func Test_AddUserWithInteractiveAccountCtx(t *testing.T) { // adding to user aa to A inputs = []interface{}{0, "aa", true, "0", "0", 0} - _, _, err = ExecuteInteractiveCmd(cmd, inputs) + _, err = ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) apk := ts.GetAccountPublicKey(t, "A") @@ -297,7 +297,7 @@ func Test_AddUserWithInteractiveCustomKey(t *testing.T) { inputs := []interface{}{"aa", false, string(sk), "0", "0"} cmd := CreateAddUserCmd() HoistRootFlags(cmd) - _, _, err = ExecuteInteractiveCmd(cmd, inputs) + _, err = ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "aa") @@ -309,7 +309,7 @@ func Test_AddUserWithInteractiveCustomKey(t *testing.T) { inputs = []interface{}{"bb", false, pk, "0", "0"} cmd = CreateAddUserCmd() HoistRootFlags(cmd) - _, _, err = ExecuteInteractiveCmd(cmd, inputs) + _, err = ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "bb") @@ -325,7 +325,7 @@ func Test_AddUserWithInteractiveCustomKey(t *testing.T) { inputs = []interface{}{"cc", false, fp, "0", "0"} cmd = CreateAddUserCmd() HoistRootFlags(cmd) - _, _, err = ExecuteInteractiveCmd(cmd, inputs) + _, err = ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "cc") @@ -347,7 +347,7 @@ func Test_AddUserWithExistingNkey(t *testing.T) { pk, err := kp.PublicKey() require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddUserCmd(), "U", "--public-key", pk) + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"U", "--public-key", pk}...) require.NoError(t, err) } @@ -356,10 +356,10 @@ func Test_AddUser_BearerToken(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UA") + _, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "UA"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UB", "--bearer") + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "UB", "--bearer"}...) require.NoError(t, err) u, err := ts.Store.ReadUserClaim("A", "UA") @@ -385,7 +385,7 @@ func Test_AddUserWithSigningKeyOnly(t *testing.T) { require.True(t, ts.KeyStore.HasPrivateKey(pk)) ts.AddAccount(t, "A") - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -394,7 +394,7 @@ func Test_AddUserWithSigningKeyOnly(t *testing.T) { ts.KeyStore.Remove(ac.Subject) require.False(t, ts.KeyStore.HasPrivateKey(ac.Subject)) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "AAA") + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "AAA"}...) require.NoError(t, err) claim, err := ts.Store.ReadUserClaim("A", "AAA") @@ -418,7 +418,7 @@ func Test_AddUserWithSigningKeyInteractive(t *testing.T) { require.True(t, ts.KeyStore.HasPrivateKey(pk)) ts.AddAccount(t, "A") - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -429,7 +429,7 @@ func Test_AddUserWithSigningKeyInteractive(t *testing.T) { inputs := []interface{}{"AAA", true, "0", "0", 1} cmd := CreateAddUserCmd() HoistRootFlags(cmd) - _, _, err = ExecuteInteractiveCmd(cmd, inputs) + _, err = ExecuteInteractiveCmd(cmd, inputs) require.NoError(t, err) claim, err := ts.Store.ReadUserClaim("A", "AAA") @@ -445,7 +445,7 @@ func Test_AddUser_QueuePermissions(t *testing.T) { ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UA", "--allow-sub", "foo queue", "--deny-sub", "bar queue") + _, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "UA", "--allow-sub", "foo queue", "--deny-sub", "bar queue"}...) require.NoError(t, err) u, err := ts.Store.ReadUserClaim("A", "UA") @@ -460,7 +460,7 @@ func Test_AddUser_SrcPermissions(t *testing.T) { ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UA", "--source-network", "1.2.1.1/29", "--source-network", "1.2.2.2/29,1.2.0.3/32") + _, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "UA", "--source-network", "1.2.1.1/29", "--source-network", "1.2.2.2/29,1.2.0.3/32"}...) require.NoError(t, err) u, err := ts.Store.ReadUserClaim("A", "UA") @@ -487,40 +487,40 @@ func Test_AddUser_Scoped(t *testing.T) { _, err = ts.KeyStore.Store(kp) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk) + _, err = ExecuteCmd(createEditAccount(), "--sk", pk) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) require.Contains(t, ac.SigningKeys, pk) - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", "--sk", pk, "--subs", "5", "--role", "user-role") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", "--sk", pk, "--subs", "5", "--role", "user-role"}...) require.NoError(t, err) // fail using key outright - _, stderr, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UA", "--tag", "foo", "--bearer", "-K", pk) + out, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UA", "--tag", "foo", "--bearer", "-K", pk) require.Error(t, err) - require.Contains(t, stderr, "[ERR ] scoped users require no permissions or limits set") + require.Contains(t, out.Err, "[ERR ] scoped users require no permissions or limits set") // fail using key via role name - _, stderr, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UB", "--tag", "foo", "--bearer", "-K", "user-role") + out, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UB", "--tag", "foo", "--bearer", "-K", "user-role") require.Error(t, err) - require.Contains(t, stderr, "[ERR ] scoped users require no permissions or limits set") + require.Contains(t, out.Err, "[ERR ] scoped users require no permissions or limits set") // pass as no permissions/limits are modified. - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UC", "--tag", "foo", "-K", "user-role") + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UC", "--tag", "foo", "-K", "user-role") require.NoError(t, err) // pass as no permissions/limits are modified. - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UD", "--tag", "foo", "-K", pk) + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UD", "--tag", "foo", "-K", pk) require.NoError(t, err) // pass as no permissions/limits are modified. - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UE", "--tag", "foo", "-K", string(s)) + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UE", "--tag", "foo", "-K", string(s)) require.NoError(t, err) // pass as no permissions/limits are modified. - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UF", "--tag", "foo", "-K", f.Name()) + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UF", "--tag", "foo", "-K", f.Name()) require.NoError(t, err) } @@ -536,23 +536,23 @@ func Test_AddUser_RotateScoped(t *testing.T) { return pk } pk1 := newKey() - _, _, err := ExecuteCmd(createEditAccount(), "--sk", pk1) + _, err := ExecuteCmd(createEditAccount(), []string{"--sk", pk1}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", "--sk", pk1, "--subs", "5", "--role", "user-role1") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", "--sk", pk1, "--subs", "5", "--role", "user-role1"}...) require.NoError(t, err) // add and edit user - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "UA", "--tag", "foo1", "-K", "user-role1") + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "UA", "--tag", "foo1", "-K", "user-role1"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), "--name", "UA", "--tag", "foo2", "-K", "user-role1") + _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), []string{"--name", "UA", "--tag", "foo2", "-K", "user-role1"}...) require.NoError(t, err) // create a second key and resign this user with it pk2 := newKey() - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk2) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pk2}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", "--sk", pk2, "--subs", "5", "--role", "user-role2") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", "--sk", pk2, "--subs", "5", "--role", "user-role2"}...) require.NoError(t, err) // With the re-signing issue in place, this edit command would fail. - _, _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), "--name", "UA", "--tag", "foo3", "-K", "user-role2") + _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), []string{"--name", "UA", "--tag", "foo3", "-K", "user-role2"}...) require.NoError(t, err) } @@ -571,23 +571,23 @@ func Test_AddUsersWithSharedSigningKey(t *testing.T) { sk := newKey() ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--sk", sk) + _, err := ExecuteCmd(createEditAccount(), []string{"--sk", sk}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) assert.Contains(t, ac.SigningKeys, sk) ts.AddAccount(t, "B") - _, _, err = ExecuteCmd(createEditAccount(), "B", "--sk", sk) + _, err = ExecuteCmd(createEditAccount(), []string{"B", "--sk", sk}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("B") require.NoError(t, err) assert.Contains(t, ac.SigningKeys, sk) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "u", "--account", "A", "-K", sk) + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"u", "--account", "A", "-K", sk}...) require.NoError(t, err) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "u", "--account", "B", "-K", sk) + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"u", "--account", "B", "-K", sk}...) require.NoError(t, err) } @@ -597,7 +597,7 @@ func Test_AddUserBadName(t *testing.T) { ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(CreateAddUserCmd(), "A/B") + _, err := ExecuteCmd(CreateAddUserCmd(), []string{"A/B"}...) require.Error(t, err) require.Contains(t, err.Error(), "name cannot contain '/' or '\\'") } @@ -606,18 +606,18 @@ func Test_AddUserRequireSk(t *testing.T) { ts := NewTestStore(t, "0") defer ts.Done(t) - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--require-signing-keys", "--sk", "generate") + _, err := ExecuteCmd(createEditOperatorCmd(), []string{"--require-signing-keys", "--sk", "generate"}...) require.NoError(t, err) ts.AddAccount(t, "A") - _, _, err = ExecuteCmd(CreateAddUserCmd(), "U") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"U"}...) require.Error(t, err) require.Equal(t, "unable to issue users when operator requires signing keys and the account has none", err.Error()) - _, _, err = ExecuteCmd(createEditAccount(), "--sk", "generate") + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", "generate"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddUserCmd(), "U") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"U"}...) require.NoError(t, err) } diff --git a/cmd/cmd_test.go b/cmd/cmd_test.go index 440cd938..93bb3842 100644 --- a/cmd/cmd_test.go +++ b/cmd/cmd_test.go @@ -17,8 +17,6 @@ package cmd import ( "bytes" - "io" - "os" "strings" "testing" @@ -69,66 +67,50 @@ func (c *CmdTest) String() string { func (c *CmdTest) RunTest(t *testing.T, chain []string, index int) { root := BuildChain(chain, c.cmd) - stdout, stderr, err := ExecuteCmd(root, c.args...) + out, err := ExecuteCmd(root, c.args...) for _, v := range c.hasOutput { - if !strings.Contains(stdout, v) { - t.Fatalf("test %d command '%v' stdout doesn't have %q\nstdout:\n%s\nstderr:\n%s\n", index, c, v, stdout, stderr) + if !strings.Contains(out.Out, v) { + t.Fatalf("test %d command '%v' stdout doesn't have %q\nstdout:\n%s\nstderr:\n%s\n", index, c, v, out.Out, out.Err) } } for _, v := range c.hasError { - if !strings.Contains(stderr, v) { - t.Fatalf("test %d command '%v' stderr doesn't have %q\nstdout:\n%s\nstderr:\n%s\n", index, c, v, stdout, stderr) + if !strings.Contains(out.Err, v) { + t.Fatalf("test %d command '%v' stderr doesn't have %q\nstdout:\n%s\nstderr:\n%s\n", index, c, v, out.Out, out.Err) } } if c.shouldFail && err == nil { - t.Fatalf("test %d command '%v' should have failed but didn't\nstdout:\n%s\nstderr:\n%s\n", index, c, stdout, stderr) + t.Fatalf("test %d command '%v' should have failed but didn't\nstdout:\n%s\nstderr:\n%s\n", index, c, out.Out, out.Err) } if !c.shouldFail && err != nil { t.Fatalf("test %d command '%v' should have not failed: %v", index, c, err) } } -func ExecuteCmd(root *cobra.Command, args ...string) (stdout string, stderr string, err error) { +type CmdOutput struct { + Out string + Err string +} + +func ExecuteCmd(root *cobra.Command, args ...string) (CmdOutput, error) { var stderrBuf, stdoutBuf bytes.Buffer - root.SetOutput(&stderrBuf) + root.SetOut(&stdoutBuf) + root.SetErr(&stderrBuf) + if len(args) == 0 { args = make([]string, 0) } root.SetArgs(args) - old := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - - _, err = root.ExecuteC() - - _ = w.Close() - os.Stdout = old - _, _ = io.Copy(&stdoutBuf, r) + _, err := root.ExecuteC() ResetSharedFlags() - - return stdoutBuf.String(), stderrBuf.String(), err + return CmdOutput{Out: stdoutBuf.String(), Err: stderrBuf.String()}, err } -func ExecuteInteractiveCmd(root *cobra.Command, inputs []interface{}, args ...string) (stdout string, stderr string, err error) { - var stderrBuf, stdoutBuf bytes.Buffer - root.SetOutput(&stderrBuf) - root.SetArgs(args) - old := os.Stdout - r, w, _ := os.Pipe() - os.Stdout = w - +func ExecuteInteractiveCmd(root *cobra.Command, inputs []interface{}, args ...string) (out CmdOutput, err error) { InteractiveFlag = true cli.SetPromptLib(cli.NewTestPrompts(inputs)) - _, err = root.ExecuteC() + out, err = ExecuteCmd(root, args...) cli.ResetPromptLib() InteractiveFlag = false - - _ = w.Close() - os.Stdout = old - _, _ = io.Copy(&stdoutBuf, r) - - ResetSharedFlags() - - return stdoutBuf.String(), stderrBuf.String(), err + return out, err } diff --git a/cmd/common.go b/cmd/common.go index e5668755..dc5d1fa6 100644 --- a/cmd/common.go +++ b/cmd/common.go @@ -101,6 +101,10 @@ func WriteJson(fp string, v interface{}) error { return nil } +func WriteFile(fp string, data []byte) error { + return os.WriteFile(fp, data, 0600) +} + func Write(fp string, data []byte) error { var err error var f *os.File diff --git a/cmd/common_test.go b/cmd/common_test.go index 34e7b821..e0f4c08a 100644 --- a/cmd/common_test.go +++ b/cmd/common_test.go @@ -40,7 +40,7 @@ func TestCommon_ResolvePath(t *testing.T) { v = ResolvePath("bar", "") require.Equal(t, v, "bar", "empty variable") - os.Setenv("foo", "foobar") + require.NoError(t, os.Setenv("foo", "foobar")) v = ResolvePath("bar", "foo") require.Equal(t, v, "foobar", "env set") } @@ -63,7 +63,7 @@ func TestCommon_GetOutput(t *testing.T) { } for _, d := range tests { if d.isDir { - os.MkdirAll(d.fp, 0777) + require.NoError(t, os.MkdirAll(d.fp, 0777)) } else if d.create { os.Create(d.fp) } @@ -85,7 +85,13 @@ func createWriteCmd(t *testing.T) *cobra.Command { cmd := &cobra.Command{ Use: "test", RunE: func(cmd *cobra.Command, args []string) error { - return Write(out, []byte("hello")) + if IsStdOut(out) { + if _, err := fmt.Fprintf(cmd.OutOrStdout(), "hello"); err != nil { + return err + } + return nil + } + return WriteFile(out, []byte("hello")) }, } cmd.Flags().StringVarP(&out, "out", "", "--", "") @@ -93,12 +99,12 @@ func createWriteCmd(t *testing.T) *cobra.Command { } func Test_WriteDestinations(t *testing.T) { - stdout, _, err := ExecuteCmd(createWriteCmd(t), "--out", "--") + out, err := ExecuteCmd(createWriteCmd(t), "--out", "--") require.NoError(t, err) - require.Contains(t, stdout, "hello") + require.Contains(t, out.Out, "hello") dir := MakeTempDir(t) fn := filepath.Join(dir, "test.txt") - _, _, err = ExecuteCmd(createWriteCmd(t), "--out", fn) + _, err = ExecuteCmd(createWriteCmd(t), "--out", fn) require.NoError(t, err) require.FileExists(t, fn) d, err := os.ReadFile(fn) @@ -208,8 +214,8 @@ func TestCommon_NKeyValidatorKeyInFile(t *testing.T) { aSeed, _, _ := CreateAccountKey(t) oSeed, _, _ := CreateOperatorKey(t) - require.NoError(t, Write(filepath.Join(dir, "as.nk"), aSeed)) - require.NoError(t, Write(filepath.Join(dir, "os.nk"), oSeed)) + require.NoError(t, WriteFile(filepath.Join(dir, "as.nk"), aSeed)) + require.NoError(t, WriteFile(filepath.Join(dir, "os.nk"), oSeed)) fn := NKeyValidator(nkeys.PrefixByteAccount) require.NoError(t, fn(filepath.Join(dir, "as.nk"))) @@ -273,7 +279,7 @@ func TestCommon_MaybeMakeDir(t *testing.T) { func TestCommon_MaybeMakeDir_FileExists(t *testing.T) { d := MakeTempDir(t) fp := filepath.Join(d, "foo") - err := Write(fp, []byte("hello")) + err := WriteFile(fp, []byte("hello")) require.NoError(t, err) err = MaybeMakeDir(fp) @@ -288,7 +294,7 @@ func TestCommon_Read(t *testing.T) { require.NoError(t, err) fp := filepath.Join(dir, "..", "..", "foo.txt") - err = Write(fp, []byte("hello")) + err = WriteFile(fp, []byte("hello")) require.NoError(t, err) require.DirExists(t, dir) @@ -318,7 +324,7 @@ func TestCommon_WriteJSON(t *testing.T) { func TestCommon_ReadJSON(t *testing.T) { d := MakeTempDir(t) fp := filepath.Join(d, "foo") - err := Write(fp, []byte(`{"name": "test"}`)) + err := WriteFile(fp, []byte(`{"name": "test"}`)) require.NoError(t, err) n := struct { diff --git a/cmd/deleteaccount_test.go b/cmd/deleteaccount_test.go index 0d3771eb..dd39bee6 100644 --- a/cmd/deleteaccount_test.go +++ b/cmd/deleteaccount_test.go @@ -28,7 +28,7 @@ func Test_DeleteAccountNotFound(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createDeleteAccountCmd(), "--name", "B") + _, err := ExecuteCmd(createDeleteAccountCmd(), []string{"--name", "B"}...) require.Error(t, err) require.Contains(t, err.Error(), "\"B\" not in accounts for operator \"O\"") } @@ -48,7 +48,7 @@ func Test_DeleteAccountOnly(t *testing.T) { require.NoError(t, err) upk := uc.Subject - _, _, err = ExecuteCmd(createDeleteAccountCmd(), "A") + _, err = ExecuteCmd(createDeleteAccountCmd(), []string{"A"}...) require.NoError(t, err) require.True(t, ts.KeyStore.HasPrivateKey(apk)) require.True(t, ts.KeyStore.HasPrivateKey(upk)) @@ -63,7 +63,7 @@ func Test_DeleteAll(t *testing.T) { ts.KeyStore.Store(kp) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--sk", pk) + _, err := ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) ts.AddUser(t, "A", "U") @@ -76,7 +76,7 @@ func Test_DeleteAll(t *testing.T) { require.NoError(t, err) upk := uc.Subject - _, _, err = ExecuteCmd(createDeleteAccountCmd(), "A", "--rm-nkey", "--rm-creds") + _, err = ExecuteCmd(createDeleteAccountCmd(), []string{"A", "--rm-nkey", "--rm-creds"}...) require.NoError(t, err) require.False(t, ts.KeyStore.HasPrivateKey(apk)) require.False(t, ts.KeyStore.HasPrivateKey(pk)) @@ -100,7 +100,7 @@ func Test_DeleteAccountInteractive(t *testing.T) { require.NoError(t, err) upk := uc.Subject - _, _, err = ExecuteInteractiveCmd(createDeleteAccountCmd(), []interface{}{false, true, true, true}, "--name", "A") + _, err = ExecuteInteractiveCmd(createDeleteAccountCmd(), []interface{}{false, true, true, true}, "--name", "A") require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") @@ -123,7 +123,7 @@ func Test_DeleteManagedAccountRequiresForceAndExpires(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createDeleteAccountCmd(), "A") + _, err := ExecuteCmd(createDeleteAccountCmd(), []string{"A"}...) require.Error(t, err) require.Contains(t, err.Error(), "--force to override") @@ -131,7 +131,7 @@ func Test_DeleteManagedAccountRequiresForceAndExpires(t *testing.T) { ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) require.Zero(t, ac.Expires) - _, _, err = ExecuteCmd(createDeleteAccountCmd(), "A", "--force") + _, err = ExecuteCmd(createDeleteAccountCmd(), []string{"A", "--force"}...) require.NoError(t, err) token := m[ac.Subject] diff --git a/cmd/deleteexport_test.go b/cmd/deleteexport_test.go index ebb6f0f3..f7beb9dc 100644 --- a/cmd/deleteexport_test.go +++ b/cmd/deleteexport_test.go @@ -33,8 +33,8 @@ func Test_DeleteExport(t *testing.T) { tests := CmdTests{ {createDeleteExportCmd(), []string{"delete", "export", "--account", "A"}, nil, []string{"subject is required"}, true}, {createDeleteExportCmd(), []string{"delete", "export", "--account", "A", "--subject", "a"}, nil, []string{"no export matching \"a\" found"}, true}, - {createDeleteExportCmd(), []string{"delete", "export", "--account", "A", "--subject", "foo"}, nil, []string{"deleted stream export \"foo\""}, false}, - {createDeleteExportCmd(), []string{"delete", "export", "--account", "B"}, nil, []string{"deleted service export \"bar\""}, false}, + {createDeleteExportCmd(), []string{"delete", "export", "--account", "A", "--subject", "foo"}, []string{"deleted stream export \"foo\""}, nil, false}, + {createDeleteExportCmd(), []string{"delete", "export", "--account", "B"}, []string{"deleted service export \"bar\""}, nil, false}, } tests.Run(t, "root", "delete") @@ -47,7 +47,7 @@ func Test_DeleteExportAccountRequired(t *testing.T) { ts.AddExport(t, "A", jwt.Stream, "foo", 0, true) ts.AddExport(t, "B", jwt.Service, "bar", 0, true) GetConfig().SetAccount("") - _, _, err := ExecuteCmd(createDeleteExportCmd(), "--subject", "foo") + _, err := ExecuteCmd(createDeleteExportCmd(), []string{"--subject", "foo"}...) require.Error(t, err) require.Contains(t, err.Error(), "account is required") } @@ -67,7 +67,7 @@ func Test_DeleteExportInteractiveManagedStore(t *testing.T) { HoistRootFlags(cmd) input := []interface{}{0, 0, 0, ts.GetAccountKeyPath(t, "A")} - _, _, err := ExecuteInteractiveCmd(cmd, input) + _, err := ExecuteInteractiveCmd(cmd, input) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") diff --git a/cmd/deleteimport_test.go b/cmd/deleteimport_test.go index 7b11b403..0a487970 100644 --- a/cmd/deleteimport_test.go +++ b/cmd/deleteimport_test.go @@ -38,7 +38,7 @@ func Test_DeleteImport(t *testing.T) { {createDeleteImportCmd(), []string{"delete", "import", "--account", "A"}, nil, []string{"account \"A\" doesn't have imports"}, true}, {createDeleteImportCmd(), []string{"delete", "import", "--account", "B"}, nil, []string{"subject is required"}, true}, {createDeleteImportCmd(), []string{"delete", "import", "--account", "B", "--subject", "baz"}, nil, []string{"no import matching \"baz\" found"}, true}, - {createDeleteImportCmd(), []string{"delete", "import", "--account", "B", "--subject", "foo"}, nil, []string{"deleted stream import \"foo\""}, false}, + {createDeleteImportCmd(), []string{"delete", "import", "--account", "B", "--subject", "foo"}, []string{"deleted stream import \"foo\""}, nil, false}, } tests.Run(t, "root", "delete") @@ -54,7 +54,7 @@ func Test_DeleteImportAccountRequired(t *testing.T) { ts.AddImport(t, "A", jwt.Stream, "foo", "B") GetConfig().SetAccount("") - _, _, err := ExecuteCmd(createDeleteImportCmd(), "--subject", "A") + _, err := ExecuteCmd(createDeleteImportCmd(), []string{"--subject", "A"}...) require.Error(t, err) require.Contains(t, err.Error(), "account is required") } @@ -74,7 +74,7 @@ func Test_DeleteImportInteractive(t *testing.T) { input := []interface{}{1, 0, 0} cmd := createDeleteImportCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, input) + _, err := ExecuteInteractiveCmd(cmd, input) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -107,15 +107,15 @@ func Test_DeleteAmbiguousImport(t *testing.T) { require.NoError(t, err) // fail because there are two with 'x' - _, _, err = ExecuteCmd(createDeleteImportCmd(), "--subject", "x") + _, err = ExecuteCmd(createDeleteImportCmd(), []string{"--subject", "x"}...) require.Error(t, err) // fail because no import for x from the specified account - _, _, err = ExecuteCmd(createDeleteImportCmd(), "--subject", "x", "--src-account", cpk) + _, err = ExecuteCmd(createDeleteImportCmd(), []string{"--subject", "x", "--src-account", cpk}...) require.Error(t, err) // finally the right args - _, _, err = ExecuteCmd(createDeleteImportCmd(), "--subject", "x", "--src-account", apk) + _, err = ExecuteCmd(createDeleteImportCmd(), []string{"--subject", "x", "--src-account", apk}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") diff --git a/cmd/deletemapping_test.go b/cmd/deletemapping_test.go index b5ba925a..0be13e74 100644 --- a/cmd/deletemapping_test.go +++ b/cmd/deletemapping_test.go @@ -16,11 +16,9 @@ package cmd import ( - "testing" - "github.com/nats-io/jwt/v2" - "github.com/stretchr/testify/require" + "testing" ) func Test_DeleteMapping(t *testing.T) { @@ -28,13 +26,13 @@ func Test_DeleteMapping(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createAddMappingCmd(), "--account", "A", "--from", "from1", "--to", "to1", "--weight", "50") + _, err := ExecuteCmd(createAddMappingCmd(), []string{"--account", "A", "--from", "from1", "--to", "to1", "--weight", "50"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createAddMappingCmd(), "--account", "A", "--from", "from1", "--to", "to2", "--weight", "50") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--account", "A", "--from", "from1", "--to", "to2", "--weight", "50"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createAddMappingCmd(), "--account", "A", "--from", "from2", "--to", "to1", "--weight", "50") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--account", "A", "--from", "from2", "--to", "to1", "--weight", "50"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createAddMappingCmd(), "--account", "A", "--from", "from2", "--to", "to2", "--weight", "50") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--account", "A", "--from", "from2", "--to", "to2", "--weight", "50"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -45,7 +43,7 @@ func Test_DeleteMapping(t *testing.T) { require.Len(t, ac.Mappings["from2"], 2) // remove all mappings for from1 - _, _, err = ExecuteCmd(createDeleteMappingCmd(), "--account", "A", "--from", "from1") + _, err = ExecuteCmd(createDeleteMappingCmd(), []string{"--account", "A", "--from", "from1"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -54,7 +52,7 @@ func Test_DeleteMapping(t *testing.T) { require.Len(t, ac.Mappings["from2"], 2) // remove particular mapping to1 from from2 - _, _, err = ExecuteCmd(createDeleteMappingCmd(), "--account", "A", "--from", "from2", "--to", "to1") + _, err = ExecuteCmd(createDeleteMappingCmd(), []string{"--account", "A", "--from", "from2", "--to", "to1"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -63,7 +61,7 @@ func Test_DeleteMapping(t *testing.T) { require.Len(t, ac.Mappings["from2"], 1) // remove non existing mapping to3 from from2 - _, _, err = ExecuteCmd(createDeleteMappingCmd(), "--account", "A", "--from", "from2", "--to", "to3") + _, err = ExecuteCmd(createDeleteMappingCmd(), []string{"--account", "A", "--from", "from2", "--to", "to3"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -72,7 +70,7 @@ func Test_DeleteMapping(t *testing.T) { require.Len(t, ac.Mappings["from2"], 1) // remove particular mapping to2 from from2 - _, _, err = ExecuteCmd(createDeleteMappingCmd(), "--account", "A", "--from", "from2", "--to", "to2") + _, err = ExecuteCmd(createDeleteMappingCmd(), []string{"--account", "A", "--from", "from2", "--to", "to2"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -86,11 +84,11 @@ func TestDeleteMappingWithCluster(t *testing.T) { ts.AddAccount(t, "A") // add a default mapping at a 100, default mapping at max - _, _, err := ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qq", "--weight", "100") + _, err := ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qq", "--weight", "100"}...) require.NoError(t, err) // add a mapping that has the same subject, but using a cluster - _, _, err = ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qq", "--weight", "100", "--cluster", "A") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qq", "--weight", "100", "--cluster", "A"}...) require.NoError(t, err) // verify we have both mappings @@ -110,7 +108,7 @@ func TestDeleteMappingWithCluster(t *testing.T) { Cluster: "A", }, m[1]) - _, _, err = ExecuteCmd(createDeleteMappingCmd(), "--from", "q", "--to", "qq") + _, err = ExecuteCmd(createDeleteMappingCmd(), []string{"--from", "q", "--to", "qq"}...) require.NoError(t, err) // deleted the one without the cluster @@ -126,10 +124,10 @@ func TestDeleteMappingWithCluster(t *testing.T) { }, m[0]) // add the default mapping again - _, _, err = ExecuteCmd(createAddMappingCmd(), "--from", "q", "--to", "qq", "--weight", "100") + _, err = ExecuteCmd(createAddMappingCmd(), []string{"--from", "q", "--to", "qq", "--weight", "100"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createDeleteMappingCmd(), "--from", "q", "--to", "qq", "--cluster", "A") + _, err = ExecuteCmd(createDeleteMappingCmd(), []string{"--from", "q", "--to", "qq", "--cluster", "A"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") diff --git a/cmd/deleteuser_test.go b/cmd/deleteuser_test.go index 8dc633db..1247297c 100644 --- a/cmd/deleteuser_test.go +++ b/cmd/deleteuser_test.go @@ -30,7 +30,7 @@ func Test_DeleteUserNotFound(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createDeleteUserCmd(), "--name", "X") + _, err := ExecuteCmd(createDeleteUserCmd(), []string{"--name", "X"}...) require.Error(t, err) _, ok := err.(*store.ResourceErr) require.True(t, ok) @@ -47,7 +47,7 @@ func Test_DeleteUserOnly(t *testing.T) { require.NoError(t, err) upk := uc.Subject - _, _, err = ExecuteCmd(createDeleteUserCmd(), "--name", "U") + _, err = ExecuteCmd(createDeleteUserCmd(), []string{"--name", "U"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") require.Error(t, err) @@ -68,7 +68,7 @@ func Test_DeleteUserAll(t *testing.T) { require.NoError(t, err) upk := uc.Subject - _, _, err = ExecuteCmd(createDeleteUserCmd(), "--name", "U", "--rm-nkey", "--rm-creds") + _, err = ExecuteCmd(createDeleteUserCmd(), []string{"--name", "U", "--rm-nkey", "--rm-creds"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") require.Error(t, err) @@ -90,7 +90,7 @@ func Test_DeleteUserInvalidate(t *testing.T) { require.NoError(t, err) upk := uc.Subject - _, _, err = ExecuteCmd(createDeleteUserCmd(), "--name", "U", "--revoke") + _, err = ExecuteCmd(createDeleteUserCmd(), []string{"--name", "U", "--revoke"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -109,7 +109,7 @@ func Test_DeleteUserInteractive(t *testing.T) { require.NoError(t, err) upk := uc.Subject - _, _, err = ExecuteInteractiveCmd(createDeleteUserCmd(), []interface{}{[]int{0}, true, true, true, true}) + _, err = ExecuteInteractiveCmd(createDeleteUserCmd(), []interface{}{[]int{0}, true, true, true, true}) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") @@ -129,7 +129,7 @@ func Test_DeleteUserFromDiffAccount(t *testing.T) { ts.AddUser(t, "A", "a") ts.AddAccount(t, "B") - _, _, err := ExecuteCmd(createDeleteUserCmd(), "a", "-a", "A") + _, err := ExecuteCmd(createDeleteUserCmd(), []string{"a", "-a", "A"}...) require.NoError(t, err) _, err = ts.Store.ReadUserClaim("A", "a") @@ -148,7 +148,7 @@ func Test_DeleteUserFromDiffAccountInteractive(t *testing.T) { require.NoError(t, err) upk := uc.Subject - _, _, err = ExecuteInteractiveCmd(createDeleteUserCmd(), []interface{}{0, []int{0}, true, true, true, true}) + _, err = ExecuteInteractiveCmd(createDeleteUserCmd(), []interface{}{0, []int{0}, true, true, true, true}) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "a") @@ -174,9 +174,9 @@ func Test_RevokeUserRequiresOperatorKey(t *testing.T) { require.NoError(t, err) require.NoError(t, ts.KeyStore.Remove(opk)) - _, _, err = ExecuteCmd(createDeleteUserCmd(), "--name", "U", "--revoke") + _, err = ExecuteCmd(createDeleteUserCmd(), []string{"--name", "U", "--revoke"}...) require.Error(t, err) - _, _, err = ExecuteCmd(createDeleteUserCmd(), "--name", "U") + _, err = ExecuteCmd(createDeleteUserCmd(), []string{"--name", "U"}...) require.NoError(t, err) } diff --git a/cmd/describe.go b/cmd/describe.go index e08cd8cf..651ca736 100644 --- a/cmd/describe.go +++ b/cmd/describe.go @@ -22,14 +22,18 @@ import ( "errors" "fmt" + "github.com/nats-io/jwt/v2" + "github.com/nats-io/nsc/v2/cmd/store" "github.com/spf13/cobra" ) -var Raw bool -var WideFlag bool -var Wide = noopNameFilter -var Json bool -var JsonPath string +var ( + Raw bool + WideFlag bool + Wide = noopNameFilter + Json bool + JsonPath string +) type WideFun = func(a string) string @@ -104,3 +108,111 @@ func bodyAsJson(data []byte) ([]byte, error) { } return j.Bytes(), nil } + +type BaseDescribe struct { + raw []byte + kind jwt.ClaimType + outputFile string +} + +func (p *BaseDescribe) Init() error { + token, err := jwt.ParseDecoratedJWT(p.raw) + if err != nil { + return err + } + p.raw = []byte(token) + gc, err := jwt.DecodeGeneric(token) + if err != nil { + return err + } + p.kind = gc.ClaimType() + return nil +} + +func (p *BaseDescribe) Describe(ctx ActionCtx) (store.Status, error) { + var out []byte + var err error + + if Raw { + out, err = p.Raw(!IsStdOut(p.outputFile)) + } else if Json || JsonPath != "" { + out, err = p.JSON(JsonPath) + } else { + out, err = p.Structured() + } + if err != nil { + return nil, err + } + if IsStdOut(p.outputFile) { + _, err = fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), string(out)) + } else { + err = WriteFile(p.outputFile, out) + } + if err != nil { + return nil, err + } + if !IsStdOut(p.outputFile) { + k := "description" + if Raw { + k = "jwt" + } + return store.OKStatus("wrote %s %s to %#q", string(p.kind), k, AbbrevHomePaths(p.outputFile)), nil + } + return nil, err +} + +func (p *BaseDescribe) Structured() ([]byte, error) { + var describer Describer + switch p.kind { + case jwt.AccountClaim: + ac, err := jwt.DecodeAccountClaims(string(p.raw)) + if err != nil { + return []byte(""), err + } + describer = NewAccountDescriber(*ac) + case jwt.ActivationClaim: + ac, err := jwt.DecodeActivationClaims(string(p.raw)) + if err != nil { + return []byte(""), err + } + describer = NewActivationDescriber(*ac) + case jwt.UserClaim: + uc, err := jwt.DecodeUserClaims(string(p.raw)) + if err != nil { + return []byte(""), err + } + describer = NewUserDescriber(*uc) + case jwt.OperatorClaim: + oc, err := jwt.DecodeOperatorClaims(string(p.raw)) + if err != nil { + return []byte(""), err + } + describer = NewOperatorDescriber(*oc) + } + + if describer == nil { + return []byte(""), fmt.Errorf("describer for %q is not implemented", p.kind) + } + return []byte(describer.Describe()), nil +} + +func (p *BaseDescribe) Raw(decorate bool) ([]byte, error) { + if decorate { + return jwt.DecorateJWT(string(p.raw)) + } + return p.raw, nil +} + +func (p *BaseDescribe) JSON(jsonPath string) ([]byte, error) { + raw, err := bodyAsJson(p.raw) + if err != nil { + return nil, err + } + if jsonPath != "" { + raw, err = GetField(raw, JsonPath) + if err != nil { + return nil, err + } + } + return raw, nil +} diff --git a/cmd/describeaccount.go b/cmd/describeaccount.go index c3472edd..19502b79 100644 --- a/cmd/describeaccount.go +++ b/cmd/describeaccount.go @@ -16,7 +16,6 @@ package cmd import ( - "github.com/nats-io/jwt/v2" "github.com/nats-io/nsc/v2/cmd/store" "github.com/spf13/cobra" ) @@ -44,9 +43,7 @@ func init() { type DescribeAccountParams struct { AccountContextParams - jwt.AccountClaims - outputFile string - raw []byte + BaseDescribe } func (p *DescribeAccountParams) SetDefaults(ctx ActionCtx) error { @@ -60,72 +57,24 @@ func (p *DescribeAccountParams) PreInteractive(ctx ActionCtx) error { func (p *DescribeAccountParams) Load(ctx ActionCtx) error { var err error - if err = p.AccountContextParams.Validate(ctx); err != nil { return err } - if Json || Raw || JsonPath != "" { - p.raw, err = ctx.StoreCtx().Store.ReadRawAccountClaim(p.AccountContextParams.Name) - if err != nil { - return err - } - if Json || JsonPath != "" { - p.raw, err = bodyAsJson(p.raw) - if err != nil { - return err - } - if JsonPath != "" { - p.raw, err = GetField(p.raw, JsonPath) - if err != nil { - return err - } - } - } - } else { - ac, err := ctx.StoreCtx().Store.ReadAccountClaim(p.AccountContextParams.Name) - if err != nil { - return err - } - p.AccountClaims = *ac + p.raw, err = ctx.StoreCtx().Store.ReadRawAccountClaim(p.AccountContextParams.Name) + if err != nil { + return err } - - return nil + return p.Init() } -func (p *DescribeAccountParams) Validate(_ ActionCtx) error { - return nil +func (p *DescribeAccountParams) Validate(ctx ActionCtx) error { + return p.AccountContextParams.Validate(ctx) } func (p *DescribeAccountParams) PostInteractive(_ ActionCtx) error { return nil } -func (p *DescribeAccountParams) Run(_ ActionCtx) (store.Status, error) { - if Raw || Json || JsonPath != "" { - if !IsStdOut(p.outputFile) && Raw { - var err error - p.raw, err = jwt.DecorateJWT(string(p.raw)) - if err != nil { - return nil, err - } - } - p.raw = append(p.raw, '\n') - if err := Write(p.outputFile, p.raw); err != nil { - return nil, err - } - } else { - v := NewAccountDescriber(p.AccountClaims).Describe() - if err := Write(p.outputFile, []byte(v)); err != nil { - return nil, err - } - } - var s store.Status - if !IsStdOut(p.outputFile) { - k := "description" - if Raw { - k = "jwt" - } - s = store.OKStatus("wrote account %s to %#q", k, AbbrevHomePaths(p.outputFile)) - } - return s, nil +func (p *DescribeAccountParams) Run(ctx ActionCtx) (store.Status, error) { + return p.Describe(ctx) } diff --git a/cmd/describeaccount_test.go b/cmd/describeaccount_test.go index 804ab464..4b598d3e 100644 --- a/cmd/describeaccount_test.go +++ b/cmd/describeaccount_test.go @@ -39,14 +39,14 @@ func TestDescribeAccount_Single(t *testing.T) { ts.AddAccount(t, "A") pub := ts.GetAccountPublicKey(t, "A") - stdout, _, err := ExecuteCmd(createDescribeAccountCmd()) + out, err := ExecuteCmd(createDescribeAccountCmd()) require.NoError(t, err) // account A public key - require.Contains(t, stdout, pub) + require.Contains(t, out.Out, pub) // operator public key - require.Contains(t, stdout, opub) + require.Contains(t, out.Out, opub) // name for the account - require.Contains(t, stdout, " A ") + require.Contains(t, out.Out, " A ") } func TestDescribeAccountRaw(t *testing.T) { @@ -55,10 +55,10 @@ func TestDescribeAccountRaw(t *testing.T) { ts.AddAccount(t, "A") Raw = true - stdout, _, err := ExecuteCmd(createDescribeAccountCmd()) + out, err := ExecuteCmd(createDescribeAccountCmd()) require.NoError(t, err) - ac, err := jwt.DecodeAccountClaims(stdout) + ac, err := jwt.DecodeAccountClaims(out.Out) require.NoError(t, err) require.NotNil(t, ac) @@ -72,10 +72,9 @@ func TestDescribeAccount_Multiple(t *testing.T) { ts.AddAccount(t, "A") ts.AddAccount(t, "B") - out, _, err := ExecuteCmd(createDescribeAccountCmd()) + out, err := ExecuteCmd(createDescribeAccountCmd()) require.NoError(t, err) - out = StripTableDecorations(out) - require.Contains(t, out, "Name B") + require.Contains(t, StripTableDecorations(out.Out), "Name B") } func TestDescribeAccount_MultipleAccountRequired(t *testing.T) { @@ -86,7 +85,7 @@ func TestDescribeAccount_MultipleAccountRequired(t *testing.T) { ts.AddAccount(t, "B") require.NoError(t, GetConfig().SetAccount("")) - _, _, err := ExecuteCmd(createDescribeAccountCmd()) + _, err := ExecuteCmd(createDescribeAccountCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "account is required") } @@ -106,11 +105,11 @@ func TestDescribeAccount_MultipleWithContext(t *testing.T) { pub := ts.GetAccountPublicKey(t, "B") - stdout, _, err := ExecuteCmd(createDescribeAccountCmd()) + out, err := ExecuteCmd(createDescribeAccountCmd()) require.NoError(t, err) - require.Contains(t, stdout, pub) - require.Contains(t, stdout, opub) - require.Contains(t, stdout, " B ") + require.Contains(t, out.Out, pub) + require.Contains(t, out.Out, opub) + require.Contains(t, out.Out, " B ") } func TestDescribeAccount_MultipleWithFlag(t *testing.T) { @@ -122,10 +121,10 @@ func TestDescribeAccount_MultipleWithFlag(t *testing.T) { pub := ts.GetAccountPublicKey(t, "B") - stdout, _, err := ExecuteCmd(createDescribeAccountCmd(), "--name", "B") + out, err := ExecuteCmd(createDescribeAccountCmd(), "--name", "B") require.NoError(t, err) - require.Contains(t, stdout, pub) - require.Contains(t, stdout, " B ") + require.Contains(t, out.Out, pub) + require.Contains(t, out.Out, " B ") } func TestDescribeAccount_MultipleWithBadAccount(t *testing.T) { @@ -135,7 +134,7 @@ func TestDescribeAccount_MultipleWithBadAccount(t *testing.T) { ts.AddAccount(t, "A") ts.AddAccount(t, "B") - _, _, err := ExecuteCmd(createDescribeAccountCmd(), "--name", "C") + _, err := ExecuteCmd(createDescribeAccountCmd(), []string{"--name", "C"}...) require.Error(t, err) } @@ -146,7 +145,7 @@ func TestDescribeAccount_Interactive(t *testing.T) { ts.AddAccount(t, "A") ts.AddAccount(t, "B") - _, _, err := ExecuteInteractiveCmd(createDescribeAccountCmd(), []interface{}{0}) + _, err := ExecuteInteractiveCmd(createDescribeAccountCmd(), []interface{}{0}) require.NoError(t, err) } @@ -164,9 +163,9 @@ func TestDescribeAccount_Latency(t *testing.T) { _, err = ts.Store.StoreClaim([]byte(token)) require.NoError(t, err) - out, _, err := ExecuteInteractiveCmd(createDescribeAccountCmd(), []interface{}{0}) + out, err := ExecuteInteractiveCmd(createDescribeAccountCmd(), []interface{}{0}, []string{}...) require.NoError(t, err) - require.Contains(t, out, "lat (10%)") + require.Contains(t, out.Out, "lat (10%)") } func TestDescribeAccount_Json(t *testing.T) { @@ -174,10 +173,10 @@ func TestDescribeAccount_Json(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - out, _, err := ExecuteCmd(rootCmd, "describe", "account", "--json") + out, err := ExecuteCmd(rootCmd, "describe", "account", "--json") require.NoError(t, err) m := make(map[string]interface{}) - err = json.Unmarshal([]byte(out), &m) + err = json.Unmarshal([]byte(out.Out), &m) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -190,11 +189,11 @@ func TestDescribeAccount_JsonPath(t *testing.T) { ts.AddAccount(t, "A") - out, _, err := ExecuteCmd(rootCmd, "describe", "account", "--field", "sub") + out, err := ExecuteCmd(rootCmd, "describe", "account", "--field", "sub") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) - require.Equal(t, fmt.Sprintf("\"%s\"\n", ac.Subject), out) + require.Equal(t, fmt.Sprintf("\"%s\"\n", ac.Subject), out.Out) } func TestDescribeAccount_JSTiers(t *testing.T) { @@ -217,13 +216,13 @@ func TestDescribeAccount_JSTiers(t *testing.T) { require.NoError(t, err) _, err = ts.Store.StoreClaim([]byte(token)) require.NoError(t, err) - out, _, err := ExecuteCmd(createDescribeAccountCmd()) + out, err := ExecuteCmd(createDescribeAccountCmd()) require.NoError(t, err) - require.Contains(t, out, " | R1") - require.Contains(t, out, " | R3") - require.Contains(t, out, " | required") - require.Contains(t, out, " | optional") - require.Contains(t, out, " | 99") + require.Contains(t, out.Out, " | R1") + require.Contains(t, out.Out, " | R3") + require.Contains(t, out.Out, " | required") + require.Contains(t, out.Out, " | optional") + require.Contains(t, out.Out, " | 99") } func TestDescribeAccount_Callout(t *testing.T) { @@ -235,17 +234,17 @@ func TestDescribeAccount_Callout(t *testing.T) { _, uPK, _ := CreateUserKey(t) _, aPK, _ := CreateAccountKey(t) _, xPK, _ := CreateCurveKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), + _, err := ExecuteCmd(createEditAuthorizationCallout(), "--auth-user", uPK, "--allowed-account", aPK, "--curve", xPK) require.NoError(t, err) - out, _, err := ExecuteCmd(createDescribeAccountCmd()) + out, err := ExecuteCmd(createDescribeAccountCmd()) require.NoError(t, err) - require.Contains(t, out, fmt.Sprintf(" | %s", uPK)) - require.Contains(t, out, fmt.Sprintf(" | %s", aPK)) - require.Contains(t, out, fmt.Sprintf(" | %s", xPK)) + require.Contains(t, out.Out, fmt.Sprintf(" | %s", uPK)) + require.Contains(t, out.Out, fmt.Sprintf(" | %s", aPK)) + require.Contains(t, out.Out, fmt.Sprintf(" | %s", xPK)) } func TestDescribeAccount_SubjectEncoding(t *testing.T) { @@ -255,9 +254,9 @@ func TestDescribeAccount_SubjectEncoding(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "foo.>", 0, true) - out, _, err := ExecuteCmd(rootCmd, "describe", "account", "--json") + out, err := ExecuteCmd(rootCmd, "describe", "account", "--json") require.NoError(t, err) - require.Contains(t, out, "foo.>") + require.Contains(t, out.Out, "foo.>") } func TestDescribeAccount_Output(t *testing.T) { @@ -267,7 +266,7 @@ func TestDescribeAccount_Output(t *testing.T) { ts.AddAccount(t, "A") p := filepath.Join(ts.Dir, "A.json") - _, _, err := ExecuteCmd(rootCmd, "describe", "account", "--json", "--output-file", p) + _, err := ExecuteCmd(rootCmd, []string{"describe", "account", "--json", "--output-file", p}...) require.NoError(t, err) data, err := os.ReadFile(p) require.NoError(t, err) @@ -277,14 +276,14 @@ func TestDescribeAccount_Output(t *testing.T) { require.Equal(t, "A", ac.Name) p = filepath.Join(ts.Dir, "A.txt") - _, _, err = ExecuteCmd(rootCmd, "describe", "account", "--output-file", p) + _, err = ExecuteCmd(rootCmd, []string{"describe", "account", "--output-file", p}...) require.NoError(t, err) data, err = os.ReadFile(p) require.NoError(t, err) strings.Contains(string(data), "Account Details") p = filepath.Join(ts.Dir, "A.jwt") - _, _, err = ExecuteCmd(rootCmd, "describe", "account", "--raw", "--output-file", p) + _, err = ExecuteCmd(rootCmd, []string{"describe", "account", "--raw", "--output-file", p}...) require.NoError(t, err) data, err = os.ReadFile(p) require.NoError(t, err) @@ -298,18 +297,18 @@ func TestDescribeAccount_Exports(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "foo.bar.*.>", 0, true) - out, _, err := ExecuteCmd(rootCmd, "describe", "account") + out, err := ExecuteCmd(rootCmd, "describe", "account") require.NoError(t, err) - require.Contains(t, out, "| Account Token Position |") - require.Contains(t, out, "foo.bar.*.> | -") + require.Contains(t, out.Out, "| Account Token Position |") + require.Contains(t, out.Out, "foo.bar.*.> | -") ts.AddAccount(t, "B") ts.AddExport(t, "B", jwt.Stream, "foo.bar.*.>", 3, true) - out, _, err = ExecuteCmd(rootCmd, "describe", "account", "-n", "B") + out, err = ExecuteCmd(rootCmd, "describe", "account", "-n", "B") require.NoError(t, err) - require.Contains(t, out, "| Account Token Position |") - require.Contains(t, out, "foo.bar.*.> | 3") + require.Contains(t, out.Out, "| Account Token Position |") + require.Contains(t, out.Out, "foo.bar.*.> | 3") } func TestDescribeAccountMore(t *testing.T) { @@ -366,32 +365,31 @@ func TestDescribeAccountMore(t *testing.T) { }) ac.Mappings = make(map[jwt.Subject][]jwt.WeightedMapping) - ac.Mappings["mapfoo"] = []jwt.WeightedMapping{jwt.WeightedMapping{Subject: "map.>", Weight: 20, Cluster: "a"}} + ac.Mappings["mapfoo"] = []jwt.WeightedMapping{{Subject: "map.>", Weight: 20, Cluster: "a"}} token, err := ac.Encode(ts.OperatorKey) require.NoError(t, err) _, err = ts.Store.StoreClaim([]byte(token)) require.NoError(t, err) - out, _, err := ExecuteCmd(rootCmd, "describe", "account", "-n", "A") + out, err := ExecuteCmd(rootCmd, "describe", "account", "-n", "A") require.NoError(t, err) - out = StripMultipleSpaces(out) - t.Log(out) - require.Contains(t, out, "| Description | hello") - require.Contains(t, out, "| Info Url | https://example.com") + stdout := StripMultipleSpaces(out.Out) + require.Contains(t, stdout, "| Description | hello") + require.Contains(t, stdout, "| Info Url | https://example.com") // order of the key may be unexpected, just find the key - require.Contains(t, out, signingKey) - require.Contains(t, out, "| Max Disk Storage | Unlimited") - require.Contains(t, out, "| Max Mem Storage | Unlimited") - require.Contains(t, out, "| Max Leaf Node Connections | 1") - require.Contains(t, out, "| Revocations | 1") - require.Contains(t, out, "| Subject | foo") - require.Contains(t, out, "| Sampling | 100%") - require.Contains(t, out, "| hello | Stream | bar.> | fromA.>") - require.Contains(t, out, "| mapfoo | map.> | 20") - - require.Contains(t, out, "| Key | "+issuer) - require.Contains(t, out, "| Role | nothing") - require.Contains(t, out, "| Description | no permissions") + require.Contains(t, stdout, signingKey) + require.Contains(t, stdout, "| Max Disk Storage | Unlimited") + require.Contains(t, stdout, "| Max Mem Storage | Unlimited") + require.Contains(t, stdout, "| Max Leaf Node Connections | 1") + require.Contains(t, stdout, "| Revocations | 1") + require.Contains(t, stdout, "| Subject | foo") + require.Contains(t, stdout, "| Sampling | 100%") + require.Contains(t, stdout, "| hello | Stream | bar.> | fromA.>") + require.Contains(t, stdout, "| mapfoo | map.> | 20") + + require.Contains(t, stdout, "| Key | "+issuer) + require.Contains(t, stdout, "| Role | nothing") + require.Contains(t, stdout, "| Description | no permissions") } diff --git a/cmd/describejwt.go b/cmd/describejwt.go index 6dcd0c13..0f4e2ff0 100644 --- a/cmd/describejwt.go +++ b/cmd/describejwt.go @@ -18,10 +18,9 @@ package cmd import ( "errors" "fmt" + "github.com/nats-io/nsc/v2/cmd/store" cli "github.com/nats-io/cliprompts/v2" - "github.com/nats-io/jwt/v2" - "github.com/nats-io/nsc/v2/cmd/store" "github.com/spf13/cobra" ) @@ -51,10 +50,8 @@ func init() { } type DescribeFile struct { - file string - kind jwt.ClaimType - outputFile string - token string + file string + BaseDescribe } func (p *DescribeFile) SetDefaults(ctx ActionCtx) error { @@ -68,106 +65,27 @@ func (p *DescribeFile) PreInteractive(ctx ActionCtx) error { } func (p *DescribeFile) Load(ctx ActionCtx) error { + var err error if p.file == "" { ctx.CurrentCmd().SilenceErrors = false ctx.CurrentCmd().SilenceUsage = false return errors.New("file is required") } - if d, err := LoadFromFileOrURL(p.file); err == nil { - p.token, err = jwt.ParseDecoratedJWT(d) - if err != nil { - return err - } - gc, err := jwt.DecodeGeneric(p.token) - if err != nil { - return err - } - p.kind = gc.ClaimType() + p.raw, err = LoadFromFileOrURL(p.file) + if err != nil { + return err } - return nil + return p.Init() } -func (p *DescribeFile) PostInteractive(ctx ActionCtx) error { +func (p *DescribeFile) Validate(_ ActionCtx) error { return nil } -func (p *DescribeFile) Validate(ctx ActionCtx) error { +func (p *DescribeFile) PostInteractive(_ ActionCtx) error { return nil } -func (p *DescribeFile) handleRaw() (store.Status, error) { - var err error - var raw []byte - if Json || JsonPath != "" { - raw, err = bodyAsJson([]byte(p.token)) - if err != nil { - return nil, err - } - if JsonPath != "" { - raw, err = GetField(raw, JsonPath) - if err != nil { - return nil, err - } - } - } - raw = append(raw, '\n') - if err := Write(p.outputFile, raw); err != nil { - return nil, err - } - var s store.Status - if !IsStdOut(p.outputFile) { - k := "description" - if Raw { - k = "jwt" - } - s = store.OKStatus("wrote jwt %s to %#q", k, AbbrevHomePaths(p.outputFile)) - } - return s, nil -} - func (p *DescribeFile) Run(ctx ActionCtx) (store.Status, error) { - if Json || Raw || JsonPath != "" { - return p.handleRaw() - } - - var describer Describer - switch p.kind { - case jwt.AccountClaim: - ac, err := jwt.DecodeAccountClaims(p.token) - if err != nil { - return nil, err - } - describer = NewAccountDescriber(*ac) - case jwt.ActivationClaim: - ac, err := jwt.DecodeActivationClaims(p.token) - if err != nil { - return nil, err - } - describer = NewActivationDescriber(*ac) - case jwt.UserClaim: - uc, err := jwt.DecodeUserClaims(p.token) - if err != nil { - return nil, err - } - describer = NewUserDescriber(*uc) - case jwt.OperatorClaim: - oc, err := jwt.DecodeOperatorClaims(p.token) - if err != nil { - return nil, err - } - describer = NewOperatorDescriber(*oc) - } - - if describer == nil { - return nil, fmt.Errorf("describer for %q is not implemented", p.kind) - } - - if err := Write(p.outputFile, []byte(describer.Describe())); err != nil { - return nil, err - } - var s store.Status - if !IsStdOut(p.outputFile) { - s = store.OKStatus("wrote account description to %#q", AbbrevHomePaths(p.outputFile)) - } - return s, nil + return p.Describe(ctx) } diff --git a/cmd/describejwt_test.go b/cmd/describejwt_test.go index 690e7807..176a0205 100644 --- a/cmd/describejwt_test.go +++ b/cmd/describejwt_test.go @@ -32,9 +32,9 @@ func TestDescribe(t *testing.T) { ts := NewTestStore(t, "test") defer ts.Done(t) - _, serr, err := ExecuteCmd(createDescribeJwtCmd()) + serr, err := ExecuteCmd(createDescribeJwtCmd(), []string{}...) require.Error(t, err) - require.Contains(t, serr, "file is required") + require.Contains(t, serr.Err, "file is required") } func TestDescribe_Operator(t *testing.T) { @@ -44,9 +44,9 @@ func TestDescribe_Operator(t *testing.T) { pub := ts.GetOperatorPublicKey(t) fp := filepath.Join(ts.GetStoresRoot(), "O", "O.jwt") - out, _, err := ExecuteCmd(createDescribeJwtCmd(), "--file", fp) + out, err := ExecuteCmd(createDescribeJwtCmd(), "--file", fp) require.NoError(t, err) - require.Contains(t, out, pub) + require.Contains(t, out.Out, pub) } func TestDescribe_Interactive(t *testing.T) { @@ -58,9 +58,9 @@ func TestDescribe_Interactive(t *testing.T) { fp := filepath.Join(ts.GetStoresRoot(), "O", store.Accounts, "A", "A.jwt") - out, _, err := ExecuteInteractiveCmd(createDescribeJwtCmd(), []interface{}{fp}) + out, err := ExecuteInteractiveCmd(createDescribeJwtCmd(), []interface{}{fp}, []string{}...) require.NoError(t, err) - require.Contains(t, out, pub) + require.Contains(t, out.Out, pub) } func TestDescribe_Account(t *testing.T) { @@ -71,9 +71,9 @@ func TestDescribe_Account(t *testing.T) { pub := ts.GetAccountPublicKey(t, "A") fp := filepath.Join(ts.GetStoresRoot(), "O", store.Accounts, "A", "A.jwt") - out, _, err := ExecuteCmd(createDescribeJwtCmd(), "--file", fp) + out, err := ExecuteCmd(createDescribeJwtCmd(), "--file", fp) require.NoError(t, err) - require.Contains(t, out, pub) + require.Contains(t, out.Out, pub) } func TestDescribe_User(t *testing.T) { @@ -85,9 +85,9 @@ func TestDescribe_User(t *testing.T) { pub := ts.GetUserPublicKey(t, "A", "a") fp := filepath.Join(ts.GetStoresRoot(), "O", store.Accounts, "A", store.Users, "a.jwt") - out, _, err := ExecuteCmd(createDescribeJwtCmd(), "--file", fp) + out, err := ExecuteCmd(createDescribeJwtCmd(), "--file", fp) require.NoError(t, err) - require.Contains(t, out, pub) + require.Contains(t, out.Out, pub) } func TestDescribe_Activation(t *testing.T) { @@ -101,18 +101,18 @@ func TestDescribe_Activation(t *testing.T) { token := ts.GenerateActivation(t, "A", "AA.>", "B") tp := filepath.Join(ts.Dir, "token.jwt") - require.NoError(t, Write(tp, []byte(token))) + require.NoError(t, WriteFile(tp, []byte(token))) - out, _, err := ExecuteCmd(createDescribeJwtCmd(), "--file", tp) + out, err := ExecuteCmd(createDescribeJwtCmd(), "--file", tp) require.NoError(t, err) - require.Contains(t, out, "AA.>") + require.Contains(t, out.Out, "AA.>") act, err := jwt.DecodeActivationClaims(token) require.NoError(t, err) hash, err := act.HashID() require.NoError(t, err) - require.Contains(t, out, hash) + require.Contains(t, out.Out, hash) } func TestDescribe_ActivationWithSigner(t *testing.T) { @@ -126,23 +126,23 @@ func TestDescribe_ActivationWithSigner(t *testing.T) { ts.AddExport(t, "A", jwt.Stream, "AA.>", 0, false) token := ts.GenerateActivation(t, "A", "AA.>", "B") tp := filepath.Join(ts.Dir, "token.jwt") - require.NoError(t, Write(tp, []byte(token))) + require.NoError(t, WriteFile(tp, []byte(token))) // verify that issuer account is not present - out, _, err := ExecuteCmd(createDescribeJwtCmd(), "--file", tp) + out, err := ExecuteCmd(createDescribeJwtCmd(), "--file", tp) require.NoError(t, err) - require.NotContains(t, out, "Issuer Account") + require.NotContains(t, out.Out, "Issuer Account") // modify the account to have a signing key _, pk, kp := CreateAccountKey(t) - _, _, err = ExecuteCmd(createEditAccount(), "-n", "A", "--sk", pk) + _, err = ExecuteCmd(createEditAccount(), "-n", "A", "--sk", pk) require.NoError(t, err) // generate an export using the account signing key token = ts.GenerateActivationWithSigner(t, "A", "AA.>", "B", kp) tp2 := filepath.Join(ts.Dir, "token2.jwt") - require.NoError(t, Write(tp2, []byte(token))) + require.NoError(t, WriteFile(tp2, []byte(token))) // verify that issuer account is present - out, _, err = ExecuteCmd(createDescribeJwtCmd(), "--file", tp2) + out, err = ExecuteCmd(createDescribeJwtCmd(), "--file", tp2) require.NoError(t, err) - require.Contains(t, out, "Issuer Account") + require.Contains(t, out.Out, "Issuer Account") } func TestDescribeJwt_Json(t *testing.T) { @@ -153,10 +153,10 @@ func TestDescribeJwt_Json(t *testing.T) { fp := filepath.Join(ts.Store.Dir, "accounts", "A", "A.jwt") t.Log(fp) - out, _, err := ExecuteCmd(rootCmd, "describe", "jwt", "--json", "--file", fp) + out, err := ExecuteCmd(rootCmd, "describe", "jwt", "--json", "--file", fp) require.NoError(t, err) m := make(map[string]interface{}) - err = json.Unmarshal([]byte(out), &m) + err = json.Unmarshal([]byte(out.Out), &m) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -170,9 +170,9 @@ func TestDescribeJwt_JsonPath(t *testing.T) { ts.AddAccount(t, "A") fp := filepath.Join(ts.Store.Dir, "accounts", "A", "A.jwt") - out, _, err := ExecuteCmd(rootCmd, "describe", "jwt", "--json", "--file", fp, "--field", "sub") + out, err := ExecuteCmd(rootCmd, "describe", "jwt", "--json", "--file", fp, "--field", "sub") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) - require.Equal(t, fmt.Sprintf("\"%s\"\n", ac.Subject), out) + require.Equal(t, fmt.Sprintf("\"%s\"\n", ac.Subject), out.Out) } diff --git a/cmd/describeoperator.go b/cmd/describeoperator.go index 17048271..fee7de1f 100644 --- a/cmd/describeoperator.go +++ b/cmd/describeoperator.go @@ -18,9 +18,8 @@ package cmd import ( "errors" "fmt" - - "github.com/nats-io/jwt/v2" "github.com/nats-io/nsc/v2/cmd/store" + "github.com/spf13/cobra" ) @@ -46,10 +45,8 @@ func init() { } type DescribeOperatorParams struct { - name string - outputFile string - claim jwt.OperatorClaims - raw []byte + name string + BaseDescribe } func (p *DescribeOperatorParams) SetDefaults(ctx ActionCtx) error { @@ -76,37 +73,16 @@ func (p *DescribeOperatorParams) SetDefaults(ctx ActionCtx) error { return nil } -func (p *DescribeOperatorParams) PreInteractive(_ ActionCtx) error { - return nil -} - func (p *DescribeOperatorParams) Load(ctx ActionCtx) error { var err error - if Json || Raw || JsonPath != "" { - p.raw, err = ctx.StoreCtx().Store.ReadRawOperatorClaim() - if err != nil { - return err - } - if Json || JsonPath != "" { - p.raw, err = bodyAsJson(p.raw) - if err != nil { - return err - } - - if JsonPath != "" { - p.raw, err = GetField(p.raw, JsonPath) - if err != nil { - return err - } - } - } - } else { - oc, err := ctx.StoreCtx().Store.ReadOperatorClaim() - if err != nil { - return err - } - p.claim = *oc + p.raw, err = ctx.StoreCtx().Store.ReadRawOperatorClaim() + if err != nil { + return err } + return p.Init() +} + +func (p *DescribeOperatorParams) PreInteractive(_ ActionCtx) error { return nil } @@ -118,33 +94,6 @@ func (p *DescribeOperatorParams) PostInteractive(_ ActionCtx) error { return nil } -func (p *DescribeOperatorParams) Run(_ ActionCtx) (store.Status, error) { - if Raw || Json || JsonPath != "" { - if !IsStdOut(p.outputFile) && Raw { - var err error - p.raw, err = jwt.DecorateJWT(string(p.raw)) - if err != nil { - return nil, err - } - } - p.raw = append(p.raw, '\n') - if err := Write(p.outputFile, p.raw); err != nil { - return nil, err - } - } else { - v := NewOperatorDescriber(p.claim).Describe() - data := []byte(v) - if err := Write(p.outputFile, data); err != nil { - return nil, err - } - } - var s store.Status - if !IsStdOut(p.outputFile) { - k := "description" - if Raw { - k = "jwt" - } - s = store.OKStatus("wrote operator %s to %#q", k, AbbrevHomePaths(p.outputFile)) - } - return s, nil +func (p *DescribeOperatorParams) Run(ctx ActionCtx) (store.Status, error) { + return p.Describe(ctx) } diff --git a/cmd/describeoperator_test.go b/cmd/describeoperator_test.go index 0d1f0734..ab6f5c8a 100644 --- a/cmd/describeoperator_test.go +++ b/cmd/describeoperator_test.go @@ -33,10 +33,10 @@ func TestDescribeOperator_Single(t *testing.T) { defer ts.Done(t) pub := ts.GetOperatorPublicKey(t) - stdout, _, err := ExecuteCmd(createDescribeOperatorCmd()) + out, err := ExecuteCmd(createDescribeOperatorCmd()) require.NoError(t, err) - require.Contains(t, stdout, pub) - require.Contains(t, stdout, " operator ") + require.Contains(t, out.Out, pub) + require.Contains(t, out.Out, " operator ") } func TestDescribeOperator_Raw(t *testing.T) { @@ -48,10 +48,10 @@ func TestDescribeOperator_Raw(t *testing.T) { Raw = oldRaw }() - stdout, _, err := ExecuteCmd(createDescribeOperatorCmd()) + stdout, err := ExecuteCmd(createDescribeOperatorCmd()) require.NoError(t, err) - oc, err := jwt.DecodeOperatorClaims(stdout) + oc, err := jwt.DecodeOperatorClaims(stdout.Out) require.NoError(t, err) require.NotNil(t, oc) @@ -64,7 +64,7 @@ func TestDescribeOperator_Multiple(t *testing.T) { ts.AddOperator(t, "A") - _, _, err := ExecuteCmd(createDescribeOperatorCmd()) + _, err := ExecuteCmd(createDescribeOperatorCmd(), []string{}...) require.NoError(t, err) } @@ -80,10 +80,10 @@ func TestDescribeOperator_MultipleWithContext(t *testing.T) { pub := ts.GetOperatorPublicKey(t) - stdout, _, err := ExecuteCmd(createDescribeOperatorCmd()) + stdout, err := ExecuteCmd(createDescribeOperatorCmd()) require.NoError(t, err) - require.Contains(t, stdout, pub) - require.Contains(t, stdout, " B ") + require.Contains(t, stdout.Out, pub) + require.Contains(t, stdout.Out, " B ") } func TestDescribeOperator_MultipleWithFlag(t *testing.T) { @@ -95,17 +95,17 @@ func TestDescribeOperator_MultipleWithFlag(t *testing.T) { pub := ts.GetOperatorPublicKey(t) - stdout, _, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "B") + stdout, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "B") require.NoError(t, err) - require.Contains(t, stdout, " B ") - require.Contains(t, stdout, pub) + require.Contains(t, stdout.Out, " B ") + require.Contains(t, stdout.Out, pub) } func TestDescribeOperator_MultipleWithBadOperator(t *testing.T) { ts := NewTestStore(t, "operator") defer ts.Done(t) - _, _, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "C") + _, err := ExecuteCmd(createDescribeOperatorCmd(), []string{"--name", "C"}...) require.Error(t, err) } @@ -113,9 +113,9 @@ func TestDescribeOperator_AccountServerURL(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - stdout, _, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "O") + stdout, err := ExecuteCmd(createDescribeOperatorCmd(), []string{"--name", "O"}...) require.NoError(t, err) - require.NotContains(t, stdout, "Account JWT Server") + require.NotContains(t, stdout.Out, "Account JWT Server") u := "https://asu.com:1234" oc, err := ts.Store.ReadOperatorClaim() @@ -127,18 +127,18 @@ func TestDescribeOperator_AccountServerURL(t *testing.T) { err = ts.Store.StoreRaw([]byte(token)) require.NoError(t, err) - stdout, _, err = ExecuteCmd(createDescribeOperatorCmd(), "--name", "O") + stdout, err = ExecuteCmd(createDescribeOperatorCmd(), "--name", "O") require.NoError(t, err) - require.Contains(t, stdout, u) + require.Contains(t, stdout.Out, u) } func TestDescribeOperator_OperatorServiceURLs(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - stdout, _, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "O") + out, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "O") require.NoError(t, err) - require.NotContains(t, stdout, "Operator Service URLs") + require.NotContains(t, out.Out, "Operator Service URLs") urls := []string{"nats://localhost:4222", "tls://localhost:4333"} oc, err := ts.Store.ReadOperatorClaim() @@ -150,21 +150,21 @@ func TestDescribeOperator_OperatorServiceURLs(t *testing.T) { _, err = ts.Store.StoreClaim([]byte(token)) require.NoError(t, err) - stdout, _, err = ExecuteCmd(createDescribeOperatorCmd(), "--name", "O") + out, err = ExecuteCmd(createDescribeOperatorCmd(), "--name", "O") require.NoError(t, err) - require.Contains(t, stdout, "Operator Service URLs") - require.Contains(t, stdout, "nats://localhost:4222") - require.Contains(t, stdout, "tls://localhost:4333") + require.Contains(t, out.Out, "Operator Service URLs") + require.Contains(t, out.Out, "nats://localhost:4222") + require.Contains(t, out.Out, "tls://localhost:4333") } func TestDescribeOperator_Json(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - out, _, err := ExecuteCmd(rootCmd, "describe", "operator", "--json") + out, err := ExecuteCmd(rootCmd, "describe", "operator", "--json") require.NoError(t, err) m := make(map[string]interface{}) - err = json.Unmarshal([]byte(out), &m) + err = json.Unmarshal([]byte(out.Out), &m) require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -176,11 +176,11 @@ func TestDescribeOperator_JsonPath(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - out, _, err := ExecuteCmd(rootCmd, "describe", "operator", "--field", "sub") + out, err := ExecuteCmd(rootCmd, "describe", "operator", "--field", "sub") require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) - require.Equal(t, fmt.Sprintf("\"%s\"\n", oc.Subject), out) + require.Equal(t, fmt.Sprintf("\"%s\"\n", oc.Subject), out.Out) } func TestDescribeOperator_Output(t *testing.T) { @@ -188,7 +188,7 @@ func TestDescribeOperator_Output(t *testing.T) { defer ts.Done(t) p := filepath.Join(ts.Dir, "O.json") - _, _, err := ExecuteCmd(rootCmd, "describe", "operator", "--json", "--output-file", p) + _, err := ExecuteCmd(rootCmd, []string{"describe", "operator", "--json", "--output-file", p}...) require.NoError(t, err) data, err := os.ReadFile(p) require.NoError(t, err) @@ -198,14 +198,14 @@ func TestDescribeOperator_Output(t *testing.T) { require.Equal(t, "O", oc.Name) p = filepath.Join(ts.Dir, "O.txt") - _, _, err = ExecuteCmd(rootCmd, "describe", "operator", "--output-file", p) + _, err = ExecuteCmd(rootCmd, []string{"describe", "operator", "--output-file", p}...) require.NoError(t, err) data, err = os.ReadFile(p) require.NoError(t, err) strings.Contains(string(data), "Operator Details") p = filepath.Join(ts.Dir, "O.jwt") - _, _, err = ExecuteCmd(rootCmd, "describe", "operator", "--raw", "--output-file", p) + _, err = ExecuteCmd(rootCmd, []string{"describe", "operator", "--raw", "--output-file", p}...) require.NoError(t, err) data, err = os.ReadFile(p) require.NoError(t, err) diff --git a/cmd/describeuser.go b/cmd/describeuser.go index e1abc181..91423ef6 100644 --- a/cmd/describeuser.go +++ b/cmd/describeuser.go @@ -48,10 +48,8 @@ func init() { type DescribeUserParams struct { AccountContextParams - jwt.UserClaims - user string - outputFile string - raw []byte + BaseDescribe + user string } func (p *DescribeUserParams) SetDefaults(ctx ActionCtx) error { @@ -61,7 +59,6 @@ func (p *DescribeUserParams) SetDefaults(ctx ActionCtx) error { func (p *DescribeUserParams) PreInteractive(ctx ActionCtx) error { var err error - if err = p.AccountContextParams.Edit(ctx); err != nil { return err } @@ -76,7 +73,6 @@ func (p *DescribeUserParams) PreInteractive(ctx ActionCtx) error { func (p *DescribeUserParams) Load(ctx ActionCtx) error { var err error - if err = p.AccountContextParams.Validate(ctx); err != nil { return err } @@ -92,73 +88,56 @@ func (p *DescribeUserParams) Load(ctx ActionCtx) error { return fmt.Errorf("user is required") } - if Json || Raw || JsonPath != "" { - p.raw, err = ctx.StoreCtx().Store.ReadRawUserClaim(p.AccountContextParams.Name, p.user) - if err != nil { - return err - } - if Json || JsonPath != "" { - p.raw, err = bodyAsJson(p.raw) - if err != nil { - return err - } - if JsonPath != "" { - p.raw, err = GetField(p.raw, JsonPath) - if err != nil { - return err - } - } - } - } else { - uc, err := ctx.StoreCtx().Store.ReadUserClaim(p.AccountContextParams.Name, p.user) - if err != nil { - return err - } - p.UserClaims = *uc + p.raw, err = ctx.StoreCtx().Store.ReadRawUserClaim(p.AccountContextParams.Name, p.user) + if err != nil { + return err } - return nil + return p.Init() } -func (p *DescribeUserParams) Validate(_ ActionCtx) error { +func (p *DescribeUserParams) PostInteractive(_ ActionCtx) error { return nil } -func (p *DescribeUserParams) PostInteractive(_ ActionCtx) error { - return nil +func (p *DescribeUserParams) Validate(ctx ActionCtx) error { + return p.AccountContextParams.Validate(ctx) } func (p *DescribeUserParams) Run(ctx ActionCtx) (store.Status, error) { if Raw || Json || JsonPath != "" { - if !IsStdOut(p.outputFile) && Raw { - var err error - p.raw, err = jwt.DecorateJWT(string(p.raw)) - if err != nil { - return nil, err - } - } - p.raw = append(p.raw, '\n') + return p.Describe(ctx) + } - if err := Write(p.outputFile, p.raw); err != nil { - return nil, err - } + d, err := p.Raw(false) + if err != nil { + return nil, err + } + uc, err := jwt.DecodeUserClaims(string(d)) + if err != nil { + return nil, err + } + ac, err := ctx.StoreCtx().Store.ReadAccountClaim(p.AccountContextParams.Name) + if err != nil { + return nil, err + } + v := NewUserDescriber(*uc).Describe() + if s, ok := ac.SigningKeys.GetScope(uc.Issuer); ok && s != nil { + v = fmt.Sprintf("%s\n%s", v, NewScopedSkDescriber(s.(*jwt.UserScope)).Describe()) + } + if IsStdOut(p.outputFile) { + _, err = fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), v) } else { - v := NewUserDescriber(p.UserClaims).Describe() - if aClaim, err := ctx.StoreCtx().Store.ReadAccountClaim(p.AccountContextParams.Name); err == nil { - if s, ok := aClaim.SigningKeys.GetScope(p.UserClaims.Issuer); ok && s != nil { - v = fmt.Sprintf("%s\n%s", v, NewScopedSkDescriber(s.(*jwt.UserScope)).Describe()) - } - } - if err := Write(p.outputFile, []byte(v)); err != nil { - return nil, err - } + err = WriteFile(p.outputFile, []byte(v)) + } + if err != nil { + return nil, err } - var s store.Status if !IsStdOut(p.outputFile) { k := "description" if Raw { k = "jwt" } - s = store.OKStatus("wrote user %s to %#q", k, AbbrevHomePaths(p.outputFile)) + return store.OKStatus("wrote %s %s to %#q", string(p.kind), k, AbbrevHomePaths(p.outputFile)), nil } - return s, nil + return nil, err } diff --git a/cmd/describeuser_test.go b/cmd/describeuser_test.go index f8b4dbfe..a0e40862 100644 --- a/cmd/describeuser_test.go +++ b/cmd/describeuser_test.go @@ -37,14 +37,14 @@ func TestDescribeUser_Single(t *testing.T) { pub := ts.GetUserPublicKey(t, "A", "a") apub := ts.GetAccountPublicKey(t, "A") - stdout, _, err := ExecuteCmd(createDescribeUserCmd()) + out, err := ExecuteCmd(createDescribeUserCmd()) require.NoError(t, err) // account A public key - require.Contains(t, stdout, apub) + require.Contains(t, out.Out, apub) // operator public key - require.Contains(t, stdout, pub) + require.Contains(t, out.Out, pub) // name for the account - require.Contains(t, stdout, " a ") + require.Contains(t, out.Out, " a ") } func TestDescribeUserRaw(t *testing.T) { @@ -55,10 +55,10 @@ func TestDescribeUserRaw(t *testing.T) { ts.AddUser(t, "A", "U") Raw = true - stdout, _, err := ExecuteCmd(createDescribeUserCmd()) + stdout, err := ExecuteCmd(createDescribeUserCmd()) require.NoError(t, err) - uc, err := jwt.DecodeUserClaims(stdout) + uc, err := jwt.DecodeUserClaims(stdout.Out) require.NoError(t, err) require.NotNil(t, uc) @@ -73,9 +73,9 @@ func TestDescribeUser_Multiple(t *testing.T) { ts.AddUser(t, "A", "a") ts.AddUser(t, "A", "b") - _, stderr, err := ExecuteCmd(createDescribeUserCmd()) + stderr, err := ExecuteCmd(createDescribeUserCmd(), []string{}...) require.Error(t, err) - require.Contains(t, stderr, "user is required") + require.Contains(t, stderr.Err, "user is required") } func TestDescribeUser_MultipleWithContext(t *testing.T) { @@ -94,11 +94,11 @@ func TestDescribeUser_MultipleWithContext(t *testing.T) { pub := ts.GetUserPublicKey(t, "B", "b") - stdout, _, err := ExecuteCmd(createDescribeUserCmd()) + out, err := ExecuteCmd(createDescribeUserCmd()) require.NoError(t, err) - require.Contains(t, stdout, apub) - require.Contains(t, stdout, pub) - require.Contains(t, stdout, " b ") + require.Contains(t, out.Out, apub) + require.Contains(t, out.Out, pub) + require.Contains(t, out.Out, " b ") } func TestDescribeUser_MultipleWithFlag(t *testing.T) { @@ -110,19 +110,19 @@ func TestDescribeUser_MultipleWithFlag(t *testing.T) { ts.AddUser(t, "B", "b") ts.AddUser(t, "B", "bb") - _, stderr, err := ExecuteCmd(createDescribeUserCmd(), "--account", "B") + out, err := ExecuteCmd(createDescribeUserCmd(), "--account", "B") require.Error(t, err) - require.Contains(t, stderr, "user is required") + require.Contains(t, out.Err, "user is required") apub := ts.GetAccountPublicKey(t, "B") pub := ts.GetUserPublicKey(t, "B", "bb") - stdout, _, err := ExecuteCmd(createDescribeUserCmd(), "--account", "B", "--name", "bb") + out, err = ExecuteCmd(createDescribeUserCmd(), "--account", "B", "--name", "bb") require.NoError(t, err) - require.Contains(t, stdout, apub) - require.Contains(t, stdout, pub) - require.Contains(t, stdout, " bb ") + require.Contains(t, out.Out, apub) + require.Contains(t, out.Out, pub) + require.Contains(t, out.Out, " bb ") } func TestDescribeUser_MultipleWithBadUser(t *testing.T) { @@ -133,13 +133,13 @@ func TestDescribeUser_MultipleWithBadUser(t *testing.T) { ts.AddAccount(t, "B") ts.AddUser(t, "B", "b") - _, _, err := ExecuteCmd(createDescribeUserCmd(), "--account", "A") + _, err := ExecuteCmd(createDescribeUserCmd(), []string{"--account", "A"}...) require.Error(t, err) - _, _, err = ExecuteCmd(createDescribeUserCmd(), "--account", "B", "--name", "a") + _, err = ExecuteCmd(createDescribeUserCmd(), []string{"--account", "B", "--name", "a"}...) require.Error(t, err) - _, _, err = ExecuteCmd(createDescribeUserCmd(), "--account", "B", "--name", "b") + _, err = ExecuteCmd(createDescribeUserCmd(), []string{"--account", "B", "--name", "b"}...) require.NoError(t, err) } @@ -151,7 +151,7 @@ func TestDescribeUser_Interactive(t *testing.T) { ts.AddAccount(t, "B") ts.AddUser(t, "B", "bb") - _, _, err := ExecuteInteractiveCmd(createDescribeUserCmd(), []interface{}{1, 0}) + _, err := ExecuteInteractiveCmd(createDescribeUserCmd(), []interface{}{1, 0}) require.NoError(t, err) } @@ -161,21 +161,21 @@ func TestDescribeUser_Account(t *testing.T) { ts.AddAccount(t, "A") _, pub, kp := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAccount(), "--name", "A", "--sk", pub) + _, err := ExecuteCmd(createEditAccount(), "--name", "A", "--sk", pub) require.NoError(t, err) // signed with default account key ts.AddUser(t, "A", "aa") - stdout, _, err := ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "aa") + out, err := ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "aa") require.NoError(t, err) - require.NotContains(t, stdout, "Issuer Account") + require.NotContains(t, out.Out, "Issuer Account") // signed with a signing key ts.AddUserWithSigner(t, "A", "bb", kp) require.NoError(t, err) - stdout, _, err = ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "bb") + out, err = ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "bb") require.NoError(t, err) - require.Contains(t, stdout, "Issuer Account") + require.Contains(t, out.Out, "Issuer Account") } func TestDescribeRawUser(t *testing.T) { @@ -184,21 +184,21 @@ func TestDescribeRawUser(t *testing.T) { ts.AddAccount(t, "A") _, pub, kp := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAccount(), "--name", "A", "--sk", pub) + _, err := ExecuteCmd(createEditAccount(), "--name", "A", "--sk", pub) require.NoError(t, err) // signed with default account key ts.AddUser(t, "A", "aa") - stdout, _, err := ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "aa") + out, err := ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "aa") require.NoError(t, err) - require.NotContains(t, stdout, "Issuer Account") + require.NotContains(t, out.Out, "Issuer Account") // signed with a signing key ts.AddUserWithSigner(t, "A", "bb", kp) require.NoError(t, err) - stdout, _, err = ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "bb") + out, err = ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "bb") require.NoError(t, err) - require.Contains(t, stdout, "Issuer Account") + require.Contains(t, out.Out, "Issuer Account") } func TestDescribeUser_Json(t *testing.T) { @@ -208,10 +208,10 @@ func TestDescribeUser_Json(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "aa") - out, _, err := ExecuteCmd(rootCmd, "describe", "user", "--json") + out, err := ExecuteCmd(rootCmd, "describe", "user", "--json") require.NoError(t, err) m := make(map[string]interface{}) - err = json.Unmarshal([]byte(out), &m) + err = json.Unmarshal([]byte(out.Out), &m) require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "aa") require.NoError(t, err) @@ -226,11 +226,11 @@ func TestDescribeUser_JsonPath(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "aa") - out, _, err := ExecuteCmd(rootCmd, "describe", "user", "--field", "sub") + out, err := ExecuteCmd(rootCmd, "describe", "user", "--field", "sub") require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "aa") require.NoError(t, err) - require.Equal(t, fmt.Sprintf("\"%s\"\n", uc.Subject), out) + require.Equal(t, fmt.Sprintf("\"%s\"\n", uc.Subject), out.Out) } func TestDescribeUser_Times(t *testing.T) { @@ -239,12 +239,12 @@ func TestDescribeUser_Times(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "aa") - _, _, err := ExecuteCmd(createEditUserCmd(), "--time", "16:04:05-17:04:09") + _, err := ExecuteCmd(createEditUserCmd(), "--time", "16:04:05-17:04:09") require.NoError(t, err) - stdout, _, err := ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "aa") + out, err := ExecuteCmd(createDescribeUserCmd(), "--account", "A", "--name", "aa") require.NoError(t, err) - require.Contains(t, stdout, "16:04:05-17:04:09") + require.Contains(t, out.Out, "16:04:05-17:04:09") } func TestDescribeUser_Output(t *testing.T) { @@ -255,7 +255,7 @@ func TestDescribeUser_Output(t *testing.T) { ts.AddUser(t, "A", "aa") p := filepath.Join(ts.Dir, "aa.json") - _, _, err := ExecuteCmd(rootCmd, "describe", "user", "-a", "A", "--json", "--output-file", p) + _, err := ExecuteCmd(rootCmd, []string{"describe", "user", "-a", "A", "--json", "--output-file", p}...) require.NoError(t, err) data, err := os.ReadFile(p) require.NoError(t, err) @@ -264,14 +264,14 @@ func TestDescribeUser_Output(t *testing.T) { require.Equal(t, "aa", uc.Name) p = filepath.Join(ts.Dir, "aa.txt") - _, _, err = ExecuteCmd(rootCmd, "describe", "user", "-a", "A", "--output-file", p) + _, err = ExecuteCmd(rootCmd, []string{"describe", "user", "-a", "A", "--output-file", p}...) require.NoError(t, err) data, err = os.ReadFile(p) require.NoError(t, err) strings.Contains(string(data), "User Details") p = filepath.Join(ts.Dir, "aa.jwt") - _, _, err = ExecuteCmd(rootCmd, "describe", "user", "-a", "A", "--raw", "--output-file", p) + _, err = ExecuteCmd(rootCmd, []string{"describe", "user", "-a", "A", "--raw", "--output-file", p}...) require.NoError(t, err) data, err = os.ReadFile(p) require.NoError(t, err) diff --git a/cmd/editaccount_test.go b/cmd/editaccount_test.go index cd3ce384..6aa0add1 100644 --- a/cmd/editaccount_test.go +++ b/cmd/editaccount_test.go @@ -35,9 +35,9 @@ func Test_EditAccount(t *testing.T) { tests := CmdTests{ {createEditAccount(), []string{"edit", "account"}, nil, []string{"specify an edit option"}, true}, - {createEditAccount(), []string{"edit", "account", "--info-url", "http://foo/bar"}, nil, []string{"changed info url to"}, false}, - {createEditAccount(), []string{"edit", "account", "--description", "my account is about this"}, nil, []string{"changed description to"}, false}, - {createEditAccount(), []string{"edit", "account", "--tag", "A", "--name", "A"}, nil, []string{"edited account \"A\""}, false}, + {createEditAccount(), []string{"edit", "account", "--info-url", "http://foo/bar"}, []string{"changed info url to"}, nil, false}, + {createEditAccount(), []string{"edit", "account", "--description", "my account is about this"}, []string{"changed description to"}, nil, false}, + {createEditAccount(), []string{"edit", "account", "--tag", "A", "--name", "A"}, []string{"edited account \"A\""}, nil, false}, } tests.Run(t, "root", "edit") @@ -50,7 +50,7 @@ func Test_EditAccountRequired(t *testing.T) { ts.AddAccount(t, "A") ts.AddAccount(t, "B") require.NoError(t, GetConfig().SetAccount("")) - _, _, err := ExecuteCmd(createEditAccount(), "--tag", "A") + _, err := ExecuteCmd(createEditAccount(), []string{"--tag", "A"}...) require.Error(t, err) require.Contains(t, "an account is required", err.Error()) } @@ -60,7 +60,7 @@ func Test_EditAccount_Tag(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--tag", "A,B,C") + _, err := ExecuteCmd(createEditAccount(), []string{"--tag", "A,B,C"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -75,10 +75,10 @@ func Test_EditAccount_RmTag(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--tag", "A,B,C") + _, err := ExecuteCmd(createEditAccount(), []string{"--tag", "A,B,C"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "--rm-tag", "A,B") + _, err = ExecuteCmd(createEditAccount(), []string{"--rm-tag", "A,B"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -94,7 +94,7 @@ func Test_EditAccount_Times(t *testing.T) { ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--start", "2018-01-01", "--expiry", "2050-01-01") + _, err := ExecuteCmd(createEditAccount(), []string{"--start", "2018-01-01", "--expiry", "2050-01-01"}...) require.NoError(t, err) start, err := ParseExpiry("2018-01-01") @@ -114,10 +114,10 @@ func Test_EditAccountLimits(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--conns", "5", "--data", "10mib", "--exports", "15", + _, err := ExecuteCmd(createEditAccount(), []string{"--conns", "5", "--data", "10mib", "--exports", "15", "--imports", "20", "--payload", "1Kib", "--subscriptions", "30", "--leaf-conns", "31", "--js-streams", "5", "--js-consumer", "6", "--js-disk-storage", "7", "--js-mem-storage", "8", - "--js-max-disk-stream", "9mib", "--js-max-mem-stream", "10", "--js-max-ack-pending", "11", "--js-max-bytes-required") + "--js-max-disk-stream", "9mib", "--js-max-mem-stream", "10", "--js-max-ack-pending", "11", "--js-max-bytes-required"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -144,8 +144,7 @@ func Test_EditJsOptionsOnTierDelete(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), - "--js-streams", "5", "--js-consumer", "6", "--js-disk-storage", "7") + _, err := ExecuteCmd(createEditAccount(), []string{"--js-streams", "5", "--js-consumer", "6", "--js-disk-storage", "7"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -154,13 +153,11 @@ func Test_EditJsOptionsOnTierDelete(t *testing.T) { require.Equal(t, int64(6), ac.Limits.Consumer) require.Equal(t, int64(7), ac.Limits.DiskStorage) - _, _, err = ExecuteCmd(createEditAccount(), - "--js-streams", "1", "--rm-js-tier", "0") + _, err = ExecuteCmd(createEditAccount(), []string{"--js-streams", "1", "--rm-js-tier", "0"}...) require.Error(t, err) require.Equal(t, "rm-js-tier is exclusive of all other js options", err.Error()) - _, _, err = ExecuteCmd(createEditAccount(), - "--rm-js-tier", "0") + _, err = ExecuteCmd(createEditAccount(), []string{"--rm-js-tier", "0"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -174,16 +171,14 @@ func Test_GlobalPreventsTiered(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), - "--js-streams", "5", "--js-disk-storage", "10") + _, err := ExecuteCmd(createEditAccount(), []string{"--js-streams", "5", "--js-disk-storage", "10"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) require.Equal(t, int64(5), ac.Limits.Streams) - _, _, err = ExecuteCmd(createEditAccount(), - "--js-tier", "1", "--js-disk-storage", "10") + _, err = ExecuteCmd(createEditAccount(), []string{"--js-tier", "1", "--js-disk-storage", "10"}...) require.Error(t, err) require.Equal(t, "cannot set a jetstream tier limit when a configuration has a global limit", err.Error()) } @@ -193,16 +188,14 @@ func Test_TieredPreventsGlobal(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), - "--js-tier", "2", "--js-streams", "5", "--js-disk-storage", "10") + _, err := ExecuteCmd(createEditAccount(), []string{"--js-tier", "2", "--js-streams", "5", "--js-disk-storage", "10"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) require.Equal(t, int64(5), ac.Limits.JetStreamTieredLimits["R2"].Streams) - _, _, err = ExecuteCmd(createEditAccount(), - "--js-disk-storage", "10") + _, err = ExecuteCmd(createEditAccount(), []string{"--js-disk-storage", "10"}...) require.Error(t, err) require.Equal(t, "cannot set a jetstream global limit when a configuration has tiered limits 'R2'", err.Error()) } @@ -212,16 +205,14 @@ func Test_TieredDoesntPreventOtherClaims(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), - "--js-tier", "2", "--js-streams", "5", "--js-disk-storage", "10") + _, err := ExecuteCmd(createEditAccount(), []string{"--js-tier", "2", "--js-streams", "5", "--js-disk-storage", "10"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) require.Equal(t, int64(5), ac.Limits.JetStreamTieredLimits["R2"].Streams) - _, _, err = ExecuteCmd(createEditAccount(), - "--sk", "generate") + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", "generate"}...) require.NoError(t, err) } @@ -233,7 +224,7 @@ func Test_EditAccountSigningKeys(t *testing.T) { _, pk, _ := CreateAccountKey(t) _, pk2, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAccount(), "--sk", pk, "--sk", pk2) + _, err := ExecuteCmd(createEditAccount(), []string{"--sk", pk, "--sk", pk2}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -241,7 +232,7 @@ func Test_EditAccountSigningKeys(t *testing.T) { require.Contains(t, ac.SigningKeys, pk) require.Contains(t, ac.SigningKeys, pk2) - _, _, err = ExecuteCmd(createEditAccount(), "--rm-sk", pk) + _, err = ExecuteCmd(createEditAccount(), []string{"--rm-sk", pk}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -255,7 +246,7 @@ func Test_EditAccount_Pubs(t *testing.T) { ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--allow-pub", "a,b", "--allow-pubsub", "c", "--deny-pub", "foo", "--deny-pubsub", "bar") + _, err := ExecuteCmd(createEditAccount(), []string{"--allow-pub", "a,b", "--allow-pubsub", "c", "--deny-pub", "foo", "--deny-pubsub", "bar"}...) require.NoError(t, err) cc, err := ts.Store.ReadAccountClaim("A") @@ -266,7 +257,7 @@ func Test_EditAccount_Pubs(t *testing.T) { require.ElementsMatch(t, cc.DefaultPermissions.Pub.Deny, []string{"foo", "bar"}) require.ElementsMatch(t, cc.DefaultPermissions.Sub.Deny, []string{"bar"}) - _, _, err = ExecuteCmd(createEditAccount(), "--rm", "c,bar") + _, err = ExecuteCmd(createEditAccount(), []string{"--rm", "c,bar"}...) require.NoError(t, err) cc, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -283,7 +274,7 @@ func Test_EditAccountResponsePermissions(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "--max-responses", "1000", "--response-ttl", "4ms") + _, err := ExecuteCmd(createEditAccount(), []string{"--max-responses", "1000", "--response-ttl", "4ms"}...) require.NoError(t, err) uc, err := ts.Store.ReadAccountClaim("A") @@ -293,7 +284,7 @@ func Test_EditAccountResponsePermissions(t *testing.T) { d, _ := time.ParseDuration("4ms") require.Equal(t, d, uc.DefaultPermissions.Resp.Expires) - _, _, err = ExecuteCmd(createEditAccount(), "--rm-response-perms") + _, err = ExecuteCmd(createEditAccount(), []string{"--rm-response-perms"}...) require.NoError(t, err) uc, err = ts.Store.ReadAccountClaim("A") @@ -312,7 +303,7 @@ func Test_EditAccountSk(t *testing.T) { pSk, err := sk.PublicKey() require.NoError(t, err) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--sk", pSk) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--sk", pSk}...) require.NoError(t, err) ts.AddAccountWithSigner(t, "A", sk) @@ -320,7 +311,7 @@ func Test_EditAccountSk(t *testing.T) { require.NoError(t, err) require.Equal(t, ac.Issuer, pSk) - _, _, err = ExecuteCmd(createEditAccount(), "--tag", "foo") + _, err = ExecuteCmd(createEditAccount(), []string{"--tag", "foo"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -333,26 +324,26 @@ func Test_EditOperatorDisallowBearerToken(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createEditUserCmd(), "--name", "U", "--bearer") + _, err := ExecuteCmd(createEditUserCmd(), []string{"--name", "U", "--bearer"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "--name", "A", "--disallow-bearer") + _, err = ExecuteCmd(createEditAccount(), []string{"--name", "A", "--disallow-bearer"}...) require.Error(t, err) require.Equal(t, err.Error(), `user "U" in account "A" uses bearer token (needs to be deleted/changed first)`) // delete offending user - _, _, err = ExecuteCmd(createDeleteUserCmd(), "--account", "A", "--name", "U") + _, err = ExecuteCmd(createDeleteUserCmd(), []string{"--account", "A", "--name", "U"}...) require.NoError(t, err) // set option - _, _, err = ExecuteCmd(createEditAccount(), "--name", "A", "--disallow-bearer") + _, err = ExecuteCmd(createEditAccount(), []string{"--name", "A", "--disallow-bearer"}...) require.NoError(t, err) // test user creation - _, _, err = ExecuteCmd(CreateAddUserCmd(), "--account", "A", "--name", "U", "--bearer") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"--account", "A", "--name", "U", "--bearer"}...) require.Error(t, err) require.Equal(t, err.Error(), `account "A" forbids the use of bearer token`) - _, _, err = ExecuteCmd(CreateAddUserCmd(), "--account", "A", "--name", "U") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"--account", "A", "--name", "U"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditUserCmd(), "--account", "A", "--name", "U", "--bearer") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--account", "A", "--name", "U", "--bearer"}...) require.Error(t, err) require.Equal(t, err.Error(), "account disallows bearer token") } @@ -361,7 +352,7 @@ func Test_EditSysAccount(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "SYS") - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--system-account", "SYS") + _, err := ExecuteCmd(createEditOperatorCmd(), []string{"--system-account", "SYS"}...) require.NoError(t, err) // test setting any flag will generate an error and the flag is reported @@ -380,17 +371,17 @@ func Test_EditSysAccount(t *testing.T) { for idx, n := range jsOptions { flag := fmt.Sprintf("--%s", n) if idx > 0 { - _, _, err = ExecuteCmd(createEditAccount(), "SYS", "--tag", "A", flag, "1") + _, err = ExecuteCmd(createEditAccount(), []string{"SYS", "--tag", "A", flag, "1"}...) require.Error(t, err) require.Contains(t, err.Error(), flag) } else { - _, _, err = ExecuteCmd(createEditAccount(), "SYS", "--tag", "A", flag) + _, err = ExecuteCmd(createEditAccount(), []string{"SYS", "--tag", "A", flag}...) require.Error(t, err) require.Contains(t, err.Error(), flag) } } // defaults are removed automatically - _, _, err = ExecuteCmd(createEditAccount(), "SYS", "--tag", "A") + _, err = ExecuteCmd(createEditAccount(), []string{"SYS", "--tag", "A"}...) require.NoError(t, err) } @@ -399,7 +390,7 @@ func Test_TierRmAndDisabled(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "A", "--rm-js-tier", "1", "--js-disable") + _, err := ExecuteCmd(createEditAccount(), []string{"A", "--rm-js-tier", "1", "--js-disable"}...) require.Error(t, err) require.Equal(t, err.Error(), "js-disable is exclusive of all other js options") } @@ -410,25 +401,25 @@ func Test_TracingSampling(t *testing.T) { ts.AddAccount(t, "A") // cannot set sampling if no subject - _, _, err := ExecuteCmd(createEditAccount(), "A", "--trace-context-sampling", "50") + _, err := ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-sampling", "50"}...) require.Error(t, err) require.Equal(t, "trace-context-sampling requires a subject", err.Error()) // set a subject - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-subject", "traces") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-subject", "traces"}...) require.NoError(t, err) // range checks - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-sampling", "101") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-sampling", "101"}...) require.Error(t, err) require.Equal(t, "tracing sampling rate must be between 1-100", err.Error()) - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-sampling", "-1") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-sampling", "-1"}...) require.Error(t, err) require.Equal(t, "tracing sampling rate must be between 1-100", err.Error()) // disable and set - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-sampling", "50", "--trace-context-subject", "") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-sampling", "50", "--trace-context-subject", ""}...) require.Error(t, err) require.Equal(t, "cannot set context sampling rate when disabling the trace context", err.Error()) } @@ -443,15 +434,15 @@ func Test_TracingSubject(t *testing.T) { require.Nil(t, ac.Trace) // no op - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-subject", "") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-subject", ""}...) require.NoError(t, err) // bad subjects are checked by jwt lib, just making sure we are catching - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-subject", "traces.*") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-subject", "traces.*"}...) require.Error(t, err) require.Equal(t, "tracing subjects cannot contain wildcards: \"traces.*\"", err.Error()) - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-subject", "traces.here") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-subject", "traces.here"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -461,7 +452,7 @@ func Test_TracingSubject(t *testing.T) { require.Equal(t, 0, ac.Trace.Sampling) // we have a subject, so set the sampling - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-sampling", "75") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-sampling", "75"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -470,7 +461,7 @@ func Test_TracingSubject(t *testing.T) { require.Equal(t, jwt.Subject("traces.here"), ac.Trace.Destination) require.Equal(t, 75, ac.Trace.Sampling) - _, _, err = ExecuteCmd(createEditAccount(), "A", "--trace-context-subject", "") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--trace-context-subject", ""}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -486,7 +477,7 @@ func Test_EnableTier(t *testing.T) { require.NoError(t, err) require.Equal(t, ac.Limits.JetStreamLimits, jwt.JetStreamLimits{}) - _, _, err = ExecuteCmd(createEditAccount(), "A", "--js-enable", "0") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--js-enable", "0"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -503,10 +494,10 @@ func Test_EnableTierDoesntClobber(t *testing.T) { require.NoError(t, err) require.Equal(t, ac.Limits.JetStreamLimits, jwt.JetStreamLimits{}) - _, _, err = ExecuteCmd(createEditAccount(), "A", "--js-enable", "0") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--js-enable", "0"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "A", "--js-enable", "0") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--js-enable", "0"}...) require.Error(t, err) require.Equal(t, "jetstream tier global is already enabled", err.Error()) } @@ -520,7 +511,7 @@ func Test_EnableTierNoOtherFlag(t *testing.T) { require.NoError(t, err) require.Equal(t, ac.Limits.JetStreamLimits, jwt.JetStreamLimits{}) - _, _, err = ExecuteCmd(createEditAccount(), "A", "--js-enable", "0", "--rm-js-tier", "0") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--js-enable", "0", "--rm-js-tier", "0"}...) require.Error(t, err) require.Equal(t, "rm-js-tier is exclusive of all other js options", err.Error()) } @@ -529,13 +520,13 @@ func Test_CannotEnableJsInSys(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "SYS") - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--system-account", "SYS") + _, err := ExecuteCmd(createEditOperatorCmd(), []string{"--system-account", "SYS"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "--js-enable", "1") + _, err = ExecuteCmd(createEditAccount(), []string{"--js-enable", "1"}...) require.Error(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "--js-disable") + _, err = ExecuteCmd(createEditAccount(), []string{"--js-disable"}...) require.NoError(t, err) sys, err := ts.Store.ReadAccountClaim("SYS") @@ -548,7 +539,7 @@ func Test_AllowSysToDisableJs(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "SYS") - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--system-account", "SYS") + _, err := ExecuteCmd(createEditOperatorCmd(), []string{"--system-account", "SYS"}...) require.NoError(t, err) sys, err := ts.Store.ReadAccountClaim("SYS") @@ -568,7 +559,7 @@ func Test_AllowSysToDisableJs(t *testing.T) { require.NoError(t, err) require.True(t, sys.Limits.IsJSEnabled()) - _, _, err = ExecuteCmd(createEditAccount(), "--js-disable") + _, err = ExecuteCmd(createEditAccount(), []string{"--js-disable"}...) require.NoError(t, err) sys, err = ts.Store.ReadAccountClaim("SYS") diff --git a/cmd/editauthorization_test.go b/cmd/editauthorization_test.go index 315261f4..919450c7 100644 --- a/cmd/editauthorization_test.go +++ b/cmd/editauthorization_test.go @@ -19,10 +19,8 @@ import ( "testing" "github.com/nats-io/jwt/v2" - "github.com/nats-io/nkeys" "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" ) @@ -32,7 +30,7 @@ func Test_EditAuthorizationNoFlags(t *testing.T) { ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAuthorizationCallout()) + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{}...) require.Error(t, err) require.Equal(t, "please specify some options", err.Error()) } @@ -44,7 +42,7 @@ func Test_EditAuthorizationBadUser(t *testing.T) { ts.AddAccount(t, "A") _, aPK, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--auth-user", aPK) + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--auth-user", aPK}...) require.Error(t, err) require.Equal(t, fmt.Sprintf("%q is not a valid user key", aPK), err.Error()) } @@ -56,7 +54,7 @@ func Test_EditAuthorizationBadAccount(t *testing.T) { ts.AddAccount(t, "A") _, aPK, _ := CreateUserKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--allowed-account", aPK) + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--allowed-account", aPK}...) require.Error(t, err) require.Equal(t, fmt.Sprintf("%q is not a valid account key", aPK), err.Error()) } @@ -66,7 +64,7 @@ func Test_EditAuthorizationBadNonNkey(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--allowed-account", "hello") + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--allowed-account", "hello"}...) require.Error(t, err) require.Equal(t, fmt.Sprintf("%q is not a valid account key", "hello"), err.Error()) } @@ -78,7 +76,7 @@ func Test_EditAuthorizationJustUser(t *testing.T) { ts.AddAccount(t, "A") _, uPK, _ := CreateUserKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--auth-user", uPK) + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--auth-user", uPK}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -93,7 +91,7 @@ func Test_EditAuthorizationJustAccount(t *testing.T) { ts.AddAccount(t, "A") _, aPK, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--allowed-account", aPK) + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--allowed-account", aPK}...) require.Error(t, err) require.Contains(t, err.Error(), "External authorization cannot have accounts without users specified") } @@ -106,7 +104,7 @@ func Test_EditAuthorizationDelete(t *testing.T) { _, uPK, _ := CreateUserKey(t) _, aPK, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--auth-user", uPK, "--allowed-account", aPK) + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--auth-user", uPK, "--allowed-account", aPK}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -114,7 +112,7 @@ func Test_EditAuthorizationDelete(t *testing.T) { require.Contains(t, ac.Authorization.AuthUsers, uPK) require.Contains(t, ac.Authorization.AllowedAccounts, aPK) - _, _, err = ExecuteCmd(createEditAuthorizationCallout(), "--disable") + _, err = ExecuteCmd(createEditAuthorizationCallout(), []string{"--disable"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -130,18 +128,18 @@ func Test_EditAuthorizationWildcardBasics(t *testing.T) { ts.AddAccount(t, "A") _, uPK, _ := CreateUserKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--auth-user", uPK, "--allowed-account", jwt.AnyAccount) + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--auth-user", uPK, "--allowed-account", jwt.AnyAccount}...) require.NoError(t, err) _, aPK, _ := CreateAccountKey(t) - _, _, err = ExecuteCmd(createEditAuthorizationCallout(), "--allowed-account", aPK) + _, err = ExecuteCmd(createEditAuthorizationCallout(), []string{"--allowed-account", aPK}...) require.Error(t, err) require.Contains(t, err.Error(), "AllowedAccounts can only be a list of accounts or \"*\"") - _, _, err = ExecuteCmd(createEditAuthorizationCallout(), "--rm-allowed-account", jwt.AnyAccount) + _, err = ExecuteCmd(createEditAuthorizationCallout(), []string{"--rm-allowed-account", jwt.AnyAccount}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAuthorizationCallout(), "--allowed-account", aPK) + _, err = ExecuteCmd(createEditAuthorizationCallout(), []string{"--allowed-account", aPK}...) require.NoError(t, err) } @@ -155,9 +153,8 @@ func Test_EditAuthorizationDeleteUser(t *testing.T) { _, u2PK, _ := CreateUserKey(t) _, aPK, _ := CreateAccountKey(t) _, a2PK, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), - "--auth-user", fmt.Sprintf("%s,%s", uPK, u2PK), - "--allowed-account", fmt.Sprintf("%s,%s", aPK, a2PK)) + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--auth-user", fmt.Sprintf("%s,%s", uPK, u2PK), + "--allowed-account", fmt.Sprintf("%s,%s", aPK, a2PK)}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -167,9 +164,8 @@ func Test_EditAuthorizationDeleteUser(t *testing.T) { require.Contains(t, ac.Authorization.AllowedAccounts, aPK) require.Contains(t, ac.Authorization.AllowedAccounts, a2PK) - _, _, err = ExecuteCmd(createEditAuthorizationCallout(), - "--rm-auth-user", u2PK, - "--rm-allowed-account", a2PK) + _, err = ExecuteCmd(createEditAuthorizationCallout(), []string{"--rm-auth-user", u2PK, + "--rm-allowed-account", a2PK}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -190,10 +186,9 @@ func Test_EditAuthorizationCurveKey(t *testing.T) { _, u2PK, _ := CreateUserKey(t) _, aPK, _ := CreateAccountKey(t) _, a2PK, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), - "--auth-user", fmt.Sprintf("%s,%s", uPK, u2PK), + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--auth-user", fmt.Sprintf("%s,%s", uPK, u2PK), "--allowed-account", fmt.Sprintf("%s,%s", aPK, a2PK), - "--curve", "generate") + "--curve", "generate"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -212,10 +207,9 @@ func Test_EditAuthorizationCurveKey(t *testing.T) { require.NoError(t, err) assert.Equal(t, "SX", string(sx[0:2])) - _, _, err = ExecuteCmd(createEditAuthorizationCallout(), - "--rm-auth-user", u2PK, + _, err = ExecuteCmd(createEditAuthorizationCallout(), []string{"--rm-auth-user", u2PK, "--rm-allowed-account", a2PK, - "--rm-curve") + "--rm-curve"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") diff --git a/cmd/editexport_test.go b/cmd/editexport_test.go index 085b41cf..a9834bbb 100644 --- a/cmd/editexport_test.go +++ b/cmd/editexport_test.go @@ -30,7 +30,7 @@ func Test_EditExport_Private(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "a", 0, true) - _, _, err := ExecuteCmd(createEditExportCmd(), "--subject", "a", "--private", "--response-type", jwt.ResponseTypeChunked) + _, err := ExecuteCmd(createEditExportCmd(), []string{"--subject", "a", "--private", "--response-type", jwt.ResponseTypeChunked}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -49,7 +49,7 @@ func Test_EditExport_Latency(t *testing.T) { require.NoError(t, err) require.Nil(t, ac.Exports[0].Latency) - _, _, err = ExecuteCmd(createEditExportCmd(), "--subject", "a", "--sampling", "100", "--latency", "lat", "--response-threshold", "1s") + _, err = ExecuteCmd(createEditExportCmd(), []string{"--subject", "a", "--sampling", "100", "--latency", "lat", "--response-threshold", "1s"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -69,7 +69,7 @@ func Test_EditExportInteractive(t *testing.T) { ts.AddExport(t, "A", jwt.Service, "b", 0, true) link := "http://foo/bar" - _, _, err := ExecuteInteractiveCmd(createEditExportCmd(), []interface{}{1, 1, "c", "c", false, false, 1, "1s", "desc", link}) + _, err := ExecuteInteractiveCmd(createEditExportCmd(), []interface{}{1, 1, "c", "c", false, false, 1, "1s", "desc", link}) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -89,7 +89,7 @@ func Test_EditExportInteractiveLatency(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "a", 0, true) - _, _, err := ExecuteInteractiveCmd(createEditExportCmd(), []interface{}{0, 1, "c", "c", false, true, "header", "lat", 2, "", "", ""}) + _, err := ExecuteInteractiveCmd(createEditExportCmd(), []interface{}{0, 1, "c", "c", false, true, "header", "lat", 2, "", "", ""}) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -109,7 +109,7 @@ func Test_EditExportRmLatencySampling(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "a", 0, true) - _, _, err := ExecuteCmd(createEditExportCmd(), "--subject", "a", "--sampling", "header", "--latency", "metrics.a") + _, err := ExecuteCmd(createEditExportCmd(), []string{"--subject", "a", "--sampling", "header", "--latency", "metrics.a"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -117,7 +117,7 @@ func Test_EditExportRmLatencySampling(t *testing.T) { require.NotNil(t, ac.Exports[0].Latency) require.Equal(t, jwt.Headers, ac.Exports[0].Latency.Sampling) - _, _, err = ExecuteCmd(createEditExportCmd(), "--subject", "a", "--rm-latency-sampling") + _, err = ExecuteCmd(createEditExportCmd(), []string{"--subject", "a", "--rm-latency-sampling"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -129,7 +129,7 @@ func Test_EditExportNoExports(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditExportCmd(), "--subject", "a") + _, err := ExecuteCmd(createEditExportCmd(), []string{"--subject", "a"}...) require.Error(t, err) require.Contains(t, err.Error(), "doesn't have exports") } @@ -139,14 +139,14 @@ func TestEditServiceExportWTracing(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createAddExportCmd(), "--service", "--subject", "q", "--allow-trace") + _, err := ExecuteCmd(createAddExportCmd(), []string{"--service", "--subject", "q", "--allow-trace"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) require.True(t, ac.Exports[0].AllowTrace) - _, _, err = ExecuteCmd(createEditExportCmd(), "--service", "--subject", "q", "--allow-trace=false") + _, err = ExecuteCmd(createEditExportCmd(), []string{"--service", "--subject", "q", "--allow-trace=false"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -159,9 +159,9 @@ func TestEditStreamExportWTracing(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createAddExportCmd(), "--subject", "q") + _, err := ExecuteCmd(createAddExportCmd(), []string{"--subject", "q"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditExportCmd(), "--subject", "q", "--allow-trace") + _, err = ExecuteCmd(createEditExportCmd(), []string{"--subject", "q", "--allow-trace"}...) require.Error(t, err) } diff --git a/cmd/editoperator_test.go b/cmd/editoperator_test.go index 9cfb35fb..38aff7ed 100644 --- a/cmd/editoperator_test.go +++ b/cmd/editoperator_test.go @@ -37,13 +37,13 @@ func Test_EditOperator(t *testing.T) { tests := CmdTests{ {createEditOperatorCmd(), []string{"edit", "operator"}, nil, []string{"specify an edit option"}, true}, - {createEditOperatorCmd(), []string{"edit", "operator", "--system-account", "ABTFVAXATJEOKIBESJ3LO3JTAAMDCZ755DLAAGGSDMH5TU6HSFL7YNYY"}, nil, []string{"set system account"}, false}, - {createEditOperatorCmd(), []string{"edit", "operator", "--system-account", "TEST"}, nil, []string{"set system account"}, false}, + {createEditOperatorCmd(), []string{"edit", "operator", "--system-account", "ABTFVAXATJEOKIBESJ3LO3JTAAMDCZ755DLAAGGSDMH5TU6HSFL7YNYY"}, []string{"set system account"}, nil, false}, + {createEditOperatorCmd(), []string{"edit", "operator", "--system-account", "TEST"}, []string{"set system account"}, nil, false}, {createEditOperatorCmd(), []string{"edit", "operator", "--system-account", "DOESNOTEXIST"}, nil, []string{"account DOESNOTEXIST does not exist in the current operator"}, true}, {createEditOperatorCmd(), []string{"edit", "operator", "--sk"}, nil, []string{"flag needs an argument"}, true}, {createEditOperatorCmd(), []string{"edit", "operator", "--sk", "SAADOZRUTPZS6LIXS6CSSSW5GXY3DNMQMSDTVWHQNHQTIBPGNSADSMBPEU"}, nil, []string{"invalid operator signing key"}, true}, - {createEditOperatorCmd(), []string{"edit", "operator", "--sk", "OBMWGGURAFWMH3AFDX65TVIH4ZYSL7UKZ3LOH2ZRWIAU7PGZ3IJNR6W5"}, nil, []string{"edited operator"}, false}, - {createEditOperatorCmd(), []string{"edit", "operator", "--tag", "O", "--start", "2019-04-13", "--expiry", "2050-01-01"}, nil, []string{"edited operator"}, false}, + {createEditOperatorCmd(), []string{"edit", "operator", "--sk", "OBMWGGURAFWMH3AFDX65TVIH4ZYSL7UKZ3LOH2ZRWIAU7PGZ3IJNR6W5"}, []string{"edited operator"}, nil, false}, + {createEditOperatorCmd(), []string{"edit", "operator", "--tag", "O", "--start", "2019-04-13", "--expiry", "2050-01-01"}, []string{"edited operator"}, nil, false}, {createEditOperatorCmd(), []string{"edit", "operator", "--require-signing-keys"}, nil, []string{"needs to be issued with a signing key first"}, true}, } @@ -70,7 +70,7 @@ func checkAcc(t *testing.T, ts *TestStore, acc string) { require.NoError(t, err) require.NotEqual(t, ac.Issuer, op.Subject) require.Equal(t, ac.Issuer, op.SigningKeys[0]) - _, _, err = ExecuteCmd(createValidateCommand(), "--all-accounts") + _, err = ExecuteCmd(createValidateCommand(), []string{"--all-accounts"}...) require.NoError(t, err) } @@ -101,31 +101,31 @@ func Test_EditOperatorRequireSigningKeys(t *testing.T) { t.Fatal(err) } // Perform all operations that would end up signing account/user/activation jwt - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--name", "O") + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--name", "O"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--sk", "generate") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--sk", "generate"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--require-signing-keys") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--require-signing-keys"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "EXPORTER") + _, err = ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "EXPORTER"}...) require.NoError(t, err) checkAcc(t, ts, "EXPORTER") - _, _, err = ExecuteCmd(createEditAccount(), "--name", "EXPORTER", "--sk", "generate") + _, err = ExecuteCmd(createEditAccount(), []string{"--name", "EXPORTER", "--sk", "generate"}...) require.NoError(t, err) checkAcc(t, ts, "EXPORTER") - _, _, err = ExecuteCmd(createAddExportCmd(), "--subject", "sub.public") + _, err = ExecuteCmd(createAddExportCmd(), []string{"--subject", "sub.public"}...) require.NoError(t, err) checkAcc(t, ts, "EXPORTER") - _, _, err = ExecuteCmd(createAddExportCmd(), "--subject", "sub.private", "--private") + _, err = ExecuteCmd(createAddExportCmd(), []string{"--subject", "sub.private", "--private"}...) require.NoError(t, err) checkAcc(t, ts, "EXPORTER") - _, _, err = ExecuteCmd(createEditExportCmd(), "--account", "EXPORTER", "--subject", "sub.public", "--description", "foo") + _, err = ExecuteCmd(createEditExportCmd(), []string{"--account", "EXPORTER", "--subject", "sub.public", "--description", "foo"}...) require.NoError(t, err) checkAcc(t, ts, "EXPORTER") - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "A") + _, err = ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "A"}...) require.NoError(t, err) checkAcc(t, ts, "A") - _, _, err = ExecuteCmd(createEditAccount(), "--name", "A", "--sk", "generate") + _, err = ExecuteCmd(createEditAccount(), []string{"--name", "A", "--sk", "generate"}...) require.NoError(t, err) checkAcc(t, ts, "A") aAc, err := jwt.DecodeAccountClaims(readJWT(t, ts.StoreDir, "O", "accounts", "A", "A.jwt")) @@ -133,41 +133,41 @@ func Test_EditOperatorRequireSigningKeys(t *testing.T) { expAc, err := jwt.DecodeAccountClaims(readJWT(t, ts.StoreDir, "O", "accounts", "EXPORTER", "EXPORTER.jwt")) require.NoError(t, err) outpath := filepath.Join(ts.Dir, "token.jwt") - _, _, err = ExecuteCmd(createGenerateActivationCmd(), "--account", "EXPORTER", "--subject", "sub.private", - "--target-account", aAc.Subject, "--output-file", outpath) + _, err = ExecuteCmd(createGenerateActivationCmd(), []string{"--account", "EXPORTER", "--subject", "sub.private", + "--target-account", aAc.Subject, "--output-file", outpath}...) require.NoError(t, err) act, err := jwt.DecodeActivationClaims(strings.Split(readJWT(t, outpath), "\n")[1]) // strip decoration require.NoError(t, err) require.NotEqual(t, act.Issuer, act.IssuerAccount) require.Equal(t, act.IssuerAccount, expAc.Subject) require.Equal(t, act.Issuer, expAc.SigningKeys.Keys()[0]) - _, _, err = ExecuteCmd(createAddImportCmd(), "--account", "A", "--token", outpath) + _, err = ExecuteCmd(createAddImportCmd(), []string{"--account", "A", "--token", outpath}...) require.NoError(t, err) checkAcc(t, ts, "A") - _, _, err = ExecuteCmd(createAddImportCmd(), "--account", "A", "--src-account", expAc.Subject, - "--remote-subject", "sub.public") + _, err = ExecuteCmd(createAddImportCmd(), []string{"--account", "A", "--src-account", expAc.Subject, + "--remote-subject", "sub.public"}...) require.NoError(t, err) checkAcc(t, ts, "A") - _, _, err = ExecuteCmd(createDeleteImportCmd(), "--account", "A", "--subject", "sub.public") + _, err = ExecuteCmd(createDeleteImportCmd(), []string{"--account", "A", "--subject", "sub.public"}...) require.NoError(t, err) checkAcc(t, ts, "A") - _, _, err = ExecuteCmd(createDeleteExportCmd(), "--account", "EXPORTER", "--subject", "sub.public") + _, err = ExecuteCmd(createDeleteExportCmd(), []string{"--account", "EXPORTER", "--subject", "sub.public"}...) require.NoError(t, err) checkAcc(t, ts, "EXPORTER") - _, _, err = ExecuteCmd(CreateAddUserCmd(), "--account", "A", "--name", "U") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"--account", "A", "--name", "U"}...) require.NoError(t, err) checkUsr(t, ts, "A") - _, _, err = ExecuteCmd(createEditUserCmd(), "--account", "A", "--name", "U", "--tag", "foo") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--account", "A", "--name", "U", "--tag", "foo"}...) require.NoError(t, err) checkUsr(t, ts, "A") - _, _, err = ExecuteCmd(createDeleteUserCmd(), "--account", "A", "--name", "U", "--revoke") + _, err = ExecuteCmd(createDeleteUserCmd(), []string{"--account", "A", "--name", "U", "--revoke"}...) require.NoError(t, err) checkAcc(t, ts, "A") uk, err := nkeys.CreateUser() require.NoError(t, err) pubUk, err := uk.PublicKey() require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeUserCmd(), "--account", "A", "--user-public-key", pubUk) + _, err = ExecuteCmd(createRevokeUserCmd(), []string{"--account", "A", "--user-public-key", pubUk}...) require.NoError(t, err) checkAcc(t, ts, "A") } @@ -190,21 +190,21 @@ func Test_EditOperatorRequireSigningKeysManaged(t *testing.T) { token, err := oc.Encode(kp) require.NoError(t, err) tf := filepath.Join(ts.Dir, "O.jwt") - err = Write(tf, []byte(token)) + err = WriteFile(tf, []byte(token)) require.NoError(t, err) - _, _, err = ExecuteCmd(createAddOperatorCmd(), "--url", tf) // causes a managed store + _, err = ExecuteCmd(createAddOperatorCmd(), []string{"--url", tf}...) // causes a managed store require.NoError(t, err) // perform operations in a managed store and assure identity is not used - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "A") + _, err = ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "A"}...) require.NoError(t, err) checkAcc(t, ts, "A") - _, _, err = ExecuteCmd(createEditAccount(), "--name", "A", "--sk", "generate") + _, err = ExecuteCmd(createEditAccount(), []string{"--name", "A", "--sk", "generate"}...) require.NoError(t, err) checkAcc(t, ts, "A") - _, _, err = ExecuteCmd(CreateAddUserCmd(), "--account", "A", "--name", "U") + _, err = ExecuteCmd(CreateAddUserCmd(), []string{"--account", "A", "--name", "U"}...) require.NoError(t, err) checkUsr(t, ts, "A") - _, _, err = ExecuteCmd(createEditUserCmd(), "--account", "A", "--name", "U", "--tag", "foo") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--account", "A", "--name", "U", "--tag", "foo"}...) require.NoError(t, err) checkUsr(t, ts, "A") } @@ -216,7 +216,7 @@ func Test_EditOperatorSigningKeys(t *testing.T) { s1, pk1, _ := CreateOperatorKey(t) _, pk2, _ := CreateOperatorKey(t) - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--sk", pk1, "--sk", pk2, "--sk", "generate") + _, err := ExecuteCmd(createEditOperatorCmd(), []string{"--sk", pk1, "--sk", pk2, "--sk", "generate"}...) require.NoError(t, err) d, err := ts.Store.Read(store.JwtName("O")) @@ -229,14 +229,14 @@ func Test_EditOperatorSigningKeys(t *testing.T) { require.Contains(t, oc.SigningKeys, pk2) require.Len(t, oc.SigningKeys, 3) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddAccountCmd()), "--name", "A", "-K", string(s1)) + _, err = ExecuteCmd(HoistRootFlags(CreateAddAccountCmd()), []string{"--name", "A", "-K", string(s1)}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) require.True(t, oc.DidSign(ac)) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--rm-sk", pk1) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--rm-sk", pk1}...) require.NoError(t, err) d, err = ts.Store.Read(store.JwtName("O")) @@ -260,7 +260,7 @@ func Test_EditOperatorServiceURLs(t *testing.T) { require.NoError(t, err) require.Len(t, oc.OperatorServiceURLs, 0) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--service-url", u1, "--service-url", u2) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--service-url", u1, "--service-url", u2}...) require.NoError(t, err) oc, err = ts.Store.ReadOperatorClaim() @@ -268,7 +268,7 @@ func Test_EditOperatorServiceURLs(t *testing.T) { require.Contains(t, oc.OperatorServiceURLs, u1) require.Contains(t, oc.OperatorServiceURLs, u2) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--rm-service-url", u1) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--rm-service-url", u1}...) require.NoError(t, err) oc, err = ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -290,7 +290,7 @@ func Test_EditOperatorServiceURLsInteractive(t *testing.T) { // system account (defaults to SYS), add signing key inputs := []interface{}{"0", "0", true, "xxx", false, as, true, u1, true, u2, false, true, false, false} - _, _, err := ExecuteInteractiveCmd(createEditOperatorCmd(), inputs) + _, err := ExecuteInteractiveCmd(createEditOperatorCmd(), inputs) require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() @@ -304,7 +304,7 @@ func Test_EditOperatorServiceURLsInteractive(t *testing.T) { // valid from, valid until, acc jwt server, add service url, remove server urls, add signing key inputs = []interface{}{"0", "0", true, []int{0}, false, "", false, true, []int{0}, false, false} - _, _, err = ExecuteInteractiveCmd(createEditOperatorCmd(), inputs) + _, err = ExecuteInteractiveCmd(createEditOperatorCmd(), inputs) require.NoError(t, err) oc, err = ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -319,14 +319,14 @@ func Test_RmAccountServiceURL(t *testing.T) { ts := NewTestStore(t, "0") defer ts.Done(t) as := "https://foo.com/v1/jwt/accounts" - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", as) + _, err := ExecuteCmd(createEditOperatorCmd(), []string{"--account-jwt-server-url", as}...) require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) require.Equal(t, as, oc.AccountServerURL) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--rm-account-jwt-server-url") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--rm-account-jwt-server-url"}...) require.NoError(t, err) oc, err = ts.Store.ReadOperatorClaim() @@ -342,7 +342,7 @@ func Test_SKGenerateAddsOneKey(t *testing.T) { require.NoError(t, err) assert.Equal(t, 1, len(keys)) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--sk", "generate") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--sk", "generate"}...) require.NoError(t, err) keys, err = ts.KeyStore.AllKeys() @@ -356,24 +356,24 @@ func Test_SysAccountCannotHaveJetStream(t *testing.T) { // global JS limits shouldn't work ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditAccount(), "A", "--js-disk-storage", "1024") + _, err := ExecuteCmd(createEditAccount(), []string{"A", "--js-disk-storage", "1024"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--system-account", "A") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--system-account", "A"}...) require.Error(t, err) require.Equal(t, err.Error(), "system accounts cannot have JetStream limits - run \"nsc edit account A --js-disable\" first") // tiered JS limits shouldn't work - _, _, err = ExecuteCmd(createEditAccount(), "A", "--js-disable") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--js-disable"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "A", "--js-tier", "3", "--js-disk-storage", "1024") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--js-tier", "3", "--js-disk-storage", "1024"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--system-account", "A") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--system-account", "A"}...) require.Error(t, err) require.Equal(t, err.Error(), "system accounts cannot have tiered JetStream limits - run \"nsc edit account A --js-disable\" first") - _, _, err = ExecuteCmd(createEditAccount(), "A", "--js-disable") + _, err = ExecuteCmd(createEditAccount(), []string{"A", "--js-disable"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--system-account", "A") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--system-account", "A"}...) require.NoError(t, err) } @@ -381,7 +381,7 @@ func Test_ExpireShouldNotBeUnset(t *testing.T) { ts := NewTestStore(t, "0") defer ts.Done(t) - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--expiry", "1y") + _, err := ExecuteCmd(createEditOperatorCmd(), []string{"--expiry", "1y"}...) require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() @@ -391,7 +391,7 @@ func Test_ExpireShouldNotBeUnset(t *testing.T) { year := time.Unix(oc.Expires, 0).UTC().Year() require.Equal(t, now+1, year) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--service-url", "nats://localhost:4222") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--service-url", "nats://localhost:4222"}...) require.NoError(t, err) oc, err = ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -402,17 +402,17 @@ func Test_CannotSetRequireSKWithoutSK(t *testing.T) { ts := NewTestStore(t, "0") defer ts.Done(t) - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--require-signing-keys") + _, err := ExecuteCmd(createEditOperatorCmd(), []string{"--require-signing-keys"}...) require.Error(t, err) require.Equal(t, "operator requires at least one signing key", err.Error()) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--require-signing-keys", "--sk", "generate") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--require-signing-keys", "--sk", "generate"}...) require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--require-signing-keys=false", "--rm-sk", oc.SigningKeys[0]) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--require-signing-keys=false", "--rm-sk", oc.SigningKeys[0]}...) require.NoError(t, err) oc, err = ts.Store.ReadOperatorClaim() diff --git a/cmd/editscopedsk_test.go b/cmd/editscopedsk_test.go index 727ec2fb..f2be5bd6 100644 --- a/cmd/editscopedsk_test.go +++ b/cmd/editscopedsk_test.go @@ -30,10 +30,10 @@ func Test_EditScopedSk_NotFound(t *testing.T) { ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createEditSkopedSkCmd(), "--account", "not there") + _, err := ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "not there"}...) require.Error(t, err) - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", "--sk", "not there") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", "--sk", "not there"}...) require.Error(t, err) } @@ -48,7 +48,7 @@ func Test_EditScopedSk_Subs(t *testing.T) { _, pk, _ := CreateAccountKey(t) s, pk2, kp := CreateAccountKey(t) - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk, "--sk", pk2) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pk, "--sk", pk2}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -80,12 +80,12 @@ func Test_EditScopedSk_Subs(t *testing.T) { require.Equal(t, us.Role, "foo") } - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", "--sk", pk2, "--subs", "5", "--role", "foo", - "--allow-pub", "foo", "--allow-sub", "foo", "--deny-sub", "bar", "--conn-type", "LEAFNODE", "--data", "5kib", "--bearer") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", "--sk", pk2, "--subs", "5", "--role", "foo", + "--allow-pub", "foo", "--allow-sub", "foo", "--deny-sub", "bar", "--conn-type", "LEAFNODE", "--data", "5kib", "--bearer"}...) require.NoError(t, err) checkAcc(5) // update using role name, with key that can't be found - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", "--sk", "foo", "--subs", "10") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", "--sk", "foo", "--subs", "10"}...) require.Error(t, err) // store seed in temporary file and keystore so it can be found @@ -97,7 +97,7 @@ func Test_EditScopedSk_Subs(t *testing.T) { _, err = ts.KeyStore.Store(kp) require.NoError(t, err) // update using role name - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", "--sk", "foo", "--subs", "10") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", "--sk", "foo", "--subs", "10"}...) require.NoError(t, err) } @@ -115,7 +115,7 @@ func Test_EditScopedSk_ResolveAny(t *testing.T) { fp, err := ts.KeyStore.Store(kp) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -123,20 +123,20 @@ func Test_EditScopedSk_ResolveAny(t *testing.T) { require.Contains(t, ac.SigningKeys, pk) require.Equal(t, ac.Issuer, oc.Subject) - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", - "--sk", string(s), "--subs", "10") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", + "--sk", string(s), "--subs", "10"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", - "--sk", pk, "--subs", "10") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", + "--sk", pk, "--subs", "10"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", - "--sk", fp, "--subs", "10") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", + "--sk", fp, "--subs", "10"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--account", "A", - "--sk", "foo", "--subs", "10") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--account", "A", + "--sk", "foo", "--subs", "10"}...) require.Error(t, err) } @@ -150,7 +150,7 @@ func Test_EditScopedSkAddGenerates(t *testing.T) { ts.AddAccount(t, "A") // add the scope with a generate - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "generate") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "generate"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -164,7 +164,7 @@ func Test_EditScopedSkAddGenerates(t *testing.T) { require.NotNil(t, us) // get the scope with the key - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", pk, "--role", "foo", "--description", "hello") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", pk, "--role", "foo", "--description", "hello"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -189,11 +189,11 @@ func Test_EditScopedSkByRole(t *testing.T) { ts.AddAccount(t, "A") // add the scope with a generate - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "generate", "--role", "foo") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "generate", "--role", "foo"}...) require.NoError(t, err) // get the scope by saying that the key is the role - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "foo", "--allow-pub", ">") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "foo", "--allow-pub", ">"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -208,7 +208,7 @@ func Test_EditScopedSkByRole(t *testing.T) { require.Len(t, us.Template.Pub.Allow, 1) // get the scope by just specifying the role - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--role", "foo", "--allow-sub", ">") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--role", "foo", "--allow-sub", ">"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -233,11 +233,11 @@ func Test_EditScopedSkConnType(t *testing.T) { ts.AddAccount(t, "A") // add the scope with a generate - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "generate", "--role", "foo") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "generate", "--role", "foo"}...) require.NoError(t, err) // try to add invalid conn type - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "foo", "--conn-type", "bar") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "foo", "--conn-type", "bar"}...) require.Error(t, err) // add lower case conn type - this is prevented now, but worked in the past @@ -263,7 +263,7 @@ func Test_EditScopedSkConnType(t *testing.T) { require.Equal(t, strings.ToLower(jwt.ConnectionTypeStandard), us.Template.AllowedConnectionTypes[0]) // add lower case conn type - should be transformed upper case - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "foo", "--conn-type", strings.ToLower(jwt.ConnectionTypeMqtt)) + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "foo", "--conn-type", strings.ToLower(jwt.ConnectionTypeMqtt)}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -290,7 +290,7 @@ func Test_EditScopedSkRmConnType(t *testing.T) { ts.AddAccount(t, "A") // add the scope with a generate - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "generate", "--role", "foo") + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "generate", "--role", "foo"}...) require.NoError(t, err) // add lower case conn types - this is prevented now, but worked in the past @@ -318,7 +318,7 @@ func Test_EditScopedSkRmConnType(t *testing.T) { require.Equal(t, strings.ToLower(jwt.ConnectionTypeWebsocket), us.Template.AllowedConnectionTypes[1]) // remove first conn type via lower cased input - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "foo", "--rm-conn-type", strings.ToLower(jwt.ConnectionTypeStandard)) + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "foo", "--rm-conn-type", strings.ToLower(jwt.ConnectionTypeStandard)}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -330,7 +330,7 @@ func Test_EditScopedSkRmConnType(t *testing.T) { require.NotNil(t, us) require.Len(t, us.Template.AllowedConnectionTypes, 1) // remove second conn type via upper cased input - _, _, err = ExecuteCmd(createEditSkopedSkCmd(), "--sk", "foo", "--rm-conn-type", jwt.ConnectionTypeWebsocket) + _, err = ExecuteCmd(createEditSkopedSkCmd(), []string{"--sk", "foo", "--rm-conn-type", jwt.ConnectionTypeWebsocket}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) diff --git a/cmd/edituser_test.go b/cmd/edituser_test.go index 7a4b7067..f2b18725 100644 --- a/cmd/edituser_test.go +++ b/cmd/edituser_test.go @@ -38,12 +38,12 @@ func Test_EditUser(t *testing.T) { tests := CmdTests{ {createEditUserCmd(), []string{"edit", "user"}, nil, []string{"specify an edit option"}, true}, - {createEditUserCmd(), []string{"edit", "user", "--tag", "A", "--account", "A"}, nil, []string{"edited user \"a\""}, false}, - {createEditUserCmd(), []string{"edit", "user", "--conn-type", "MQTT", "--rm-conn-type", "LEAFNODE", "--account", "A"}, nil, []string{"added connection type MQTT", "added connection type MQTT"}, false}, - {createEditUserCmd(), []string{"edit", "user", "--conn-type", "LEAFNODE_WS", "--account", "A"}, nil, []string{"added connection type LEAFNODE_WS"}, false}, - {createEditUserCmd(), []string{"edit", "user", "--conn-type", "MQTT_WS", "--account", "A"}, nil, []string{"added connection type MQTT_WS"}, false}, + {createEditUserCmd(), []string{"edit", "user", "--tag", "A", "--account", "A"}, []string{"edited user \"a\""}, nil, false}, + {createEditUserCmd(), []string{"edit", "user", "--conn-type", "MQTT", "--rm-conn-type", "LEAFNODE", "--account", "A"}, []string{"added connection type MQTT", "added connection type MQTT"}, nil, false}, + {createEditUserCmd(), []string{"edit", "user", "--conn-type", "LEAFNODE_WS", "--account", "A"}, []string{"added connection type LEAFNODE_WS"}, nil, false}, + {createEditUserCmd(), []string{"edit", "user", "--conn-type", "MQTT_WS", "--account", "A"}, []string{"added connection type MQTT_WS"}, nil, false}, {createEditUserCmd(), []string{"edit", "user", "--tag", "B", "--account", "B"}, nil, []string{"user name is required"}, true}, - {createEditUserCmd(), []string{"edit", "user", "--tag", "B", "--account", "B", "--name", "bb"}, nil, []string{"edited user \"bb\""}, false}, + {createEditUserCmd(), []string{"edit", "user", "--tag", "B", "--account", "B", "--name", "bb"}, []string{"edited user \"bb\""}, nil, false}, } tests.Run(t, "root", "edit") @@ -56,7 +56,7 @@ func Test_EditUserInteractive(t *testing.T) { inputs := []interface{}{"-1", "2018-01-01", "2050-01-01", false} cli.LogFn = t.Log - _, _, err := ExecuteInteractiveCmd(createEditUserCmd(), inputs) + _, err := ExecuteInteractiveCmd(createEditUserCmd(), inputs) require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "U") @@ -72,24 +72,6 @@ func Test_EditUserInteractive(t *testing.T) { require.Nil(t, uc.Resp) } -func Test_EditUserEditResponsePermissions(t *testing.T) { - t.Skip("response permissions not interactive") - ts := NewTestStore(t, "O") - defer ts.Done(t) - ts.AddUser(t, "A", "U") - - inputs := []interface{}{true, 100, "1000ms", -1, 0, 0, false} - _, _, err := ExecuteInteractiveCmd(createEditUserCmd(), inputs) - require.NoError(t, err) - - uc, err := ts.Store.ReadUserClaim("A", "U") - require.NoError(t, err) - - require.NotNil(t, uc.Resp) - require.Equal(t, 100, uc.Resp.MaxMsgs) - require.Equal(t, time.Millisecond*1000, uc.Resp.Expires) -} - func Test_EditUserAccountRequired(t *testing.T) { ts := NewTestStore(t, "edit user") defer ts.Done(t) @@ -97,7 +79,7 @@ func Test_EditUserAccountRequired(t *testing.T) { ts.AddUser(t, "A", "a") ts.AddUser(t, "B", "b") require.NoError(t, GetConfig().SetAccount("")) - _, _, err := ExecuteCmd(createEditUserCmd(), "--tag", "A") + _, err := ExecuteCmd(createEditUserCmd(), []string{"--tag", "A"}...) require.Error(t, err) require.Contains(t, err.Error(), "account is required") } @@ -107,7 +89,7 @@ func Test_EditUser_Tag(t *testing.T) { defer ts.Done(t) ts.AddUser(t, "A", "a") - _, _, err := ExecuteCmd(createEditUserCmd(), "--tag", "A,B,C") + _, err := ExecuteCmd(createEditUserCmd(), []string{"--tag", "A,B,C"}...) require.NoError(t, err) cc, err := ts.Store.ReadUserClaim("A", "a") @@ -117,7 +99,7 @@ func Test_EditUser_Tag(t *testing.T) { require.Len(t, cc.Tags, 3) require.ElementsMatch(t, cc.Tags, []string{"a", "b", "c"}) - _, _, err = ExecuteCmd(createEditUserCmd(), "--rm-tag", "A,B") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--rm-tag", "A,B"}...) require.NoError(t, err) cc, err = ts.Store.ReadUserClaim("A", "a") @@ -135,7 +117,7 @@ func Test_EditUser_Pubs(t *testing.T) { ts.AddUser(t, "A", "a") - _, _, err := ExecuteCmd(createEditUserCmd(), "--allow-pub", "a,b", "--allow-pubsub", "c", "--deny-pub", "foo", "--deny-pubsub", "bar") + _, err := ExecuteCmd(createEditUserCmd(), []string{"--allow-pub", "a,b", "--allow-pubsub", "c", "--deny-pub", "foo", "--deny-pubsub", "bar"}...) require.NoError(t, err) cc, err := ts.Store.ReadUserClaim("A", "a") @@ -146,7 +128,7 @@ func Test_EditUser_Pubs(t *testing.T) { require.ElementsMatch(t, cc.Pub.Deny, []string{"foo", "bar"}) require.ElementsMatch(t, cc.Sub.Deny, []string{"bar"}) - _, _, err = ExecuteCmd(createEditUserCmd(), "--rm", "c,bar") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--rm", "c,bar"}...) require.NoError(t, err) cc, err = ts.Store.ReadUserClaim("A", "a") require.NoError(t, err) @@ -164,7 +146,7 @@ func Test_EditUser_Src(t *testing.T) { ts.AddUser(t, "A", "a") - _, _, err := ExecuteCmd(createEditUserCmd(), "--source-network", "192.0.2.0/24,192.0.1.0/8") + _, err := ExecuteCmd(createEditUserCmd(), []string{"--source-network", "192.0.2.0/24,192.0.1.0/8"}...) require.NoError(t, err) cc, err := ts.Store.ReadUserClaim("A", "a") @@ -172,7 +154,7 @@ func Test_EditUser_Src(t *testing.T) { require.NotNil(t, cc) require.ElementsMatch(t, cc.Src, []string{"192.0.2.0/24", "192.0.1.0/8"}) - _, _, err = ExecuteCmd(createEditUserCmd(), "--rm-source-network", "192.0.2.0/24") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--rm-source-network", "192.0.2.0/24"}...) require.NoError(t, err) cc, err = ts.Store.ReadUserClaim("A", "a") @@ -187,7 +169,7 @@ func Test_EditUser_Times(t *testing.T) { ts.AddUser(t, "A", "a") - _, _, err := ExecuteCmd(createEditUserCmd(), "--time", "16:04:05-17:04:09", "--time", "18:04:05-19:04:09", "--locale", "America/New_York") + _, err := ExecuteCmd(createEditUserCmd(), []string{"--time", "16:04:05-17:04:09", "--time", "18:04:05-19:04:09", "--locale", "America/New_York"}...) require.NoError(t, err) cc, err := ts.Store.ReadUserClaim("A", "a") @@ -199,7 +181,7 @@ func Test_EditUser_Times(t *testing.T) { {Start: "18:04:05", End: "19:04:09"}}) require.Equal(t, "America/New_York", cc.Locale) - _, _, err = ExecuteCmd(createEditUserCmd(), "--rm-time", "16:04:05", "--locale", "") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--rm-time", "16:04:05", "--locale", ""}...) require.NoError(t, err) cc, err = ts.Store.ReadUserClaim("A", "a") @@ -216,7 +198,7 @@ func Test_EditUserSK(t *testing.T) { s, p, _ := CreateAccountKey(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(HoistRootFlags(createEditAccount()), "--name", "A", "--sk", p) + _, err := ExecuteCmd(HoistRootFlags(createEditAccount()), []string{"--name", "A", "--sk", p}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -229,7 +211,7 @@ func Test_EditUserSK(t *testing.T) { require.Equal(t, uc.Issuer, ac.Subject) require.Empty(t, uc.IssuerAccount) - _, _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), "-n", "U", "--allow-pub", "foo", "-K", string(s)) + _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), []string{"-n", "U", "--allow-pub", "foo", "-K", string(s)}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) @@ -243,7 +225,7 @@ func Test_EditUserAddedWithSK(t *testing.T) { s, p, sk := CreateAccountKey(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(HoistRootFlags(createEditAccount()), "--name", "A", "--sk", p) + _, err := ExecuteCmd(HoistRootFlags(createEditAccount()), []string{"--name", "A", "--sk", p}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -256,7 +238,7 @@ func Test_EditUserAddedWithSK(t *testing.T) { require.Equal(t, uc.Issuer, p) require.Equal(t, uc.IssuerAccount, ac.Subject) - _, _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), "-n", "U", "--allow-pub", "foo", "-K", string(s)) + _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), []string{"-n", "U", "--allow-pub", "foo", "-K", string(s)}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) @@ -270,7 +252,7 @@ func Test_EditUser_Payload(t *testing.T) { ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createEditUserCmd(), "--payload", "1000") + _, err := ExecuteCmd(createEditUserCmd(), []string{"--payload", "1000"}...) require.NoError(t, err) cc, err := ts.Store.ReadUserClaim("A", "U") @@ -278,7 +260,7 @@ func Test_EditUser_Payload(t *testing.T) { require.NotNil(t, cc) require.Equal(t, int64(1000), cc.Limits.Payload) - _, _, err = ExecuteCmd(createEditUserCmd(), "--payload", "-1") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--payload", "-1"}...) require.NoError(t, err) cc, err = ts.Store.ReadUserClaim("A", "U") @@ -292,14 +274,14 @@ func Test_EditUserResponsePermissions(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(CreateAddUserCmd(), "U", "--max-responses", "100", "--response-ttl", "2ms") + _, err := ExecuteCmd(CreateAddUserCmd(), []string{"U", "--max-responses", "100", "--response-ttl", "2ms"}...) require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) require.NotNil(t, uc.Resp) - _, _, err = ExecuteCmd(createEditUserCmd(), "--max-responses", "1000", "--response-ttl", "4ms") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--max-responses", "1000", "--response-ttl", "4ms"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") @@ -309,7 +291,7 @@ func Test_EditUserResponsePermissions(t *testing.T) { d, _ := time.ParseDuration("4ms") require.Equal(t, d, uc.Resp.Expires) - _, _, err = ExecuteCmd(createEditUserCmd(), "--rm-response-perms") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--rm-response-perms"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") @@ -322,14 +304,14 @@ func Test_EditUserResponsePermissions2(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(CreateAddUserCmd(), "U", "--allow-pub-response", "--response-ttl", "2ms") + _, err := ExecuteCmd(CreateAddUserCmd(), []string{"U", "--allow-pub-response", "--response-ttl", "2ms"}...) require.NoError(t, err) uc, err := ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) require.NotNil(t, uc.Resp) require.Equal(t, 1, uc.Resp.MaxMsgs) - _, _, err = ExecuteCmd(createEditUserCmd(), "U", "--allow-pub-response=100", "--response-ttl", "2ms") + _, err = ExecuteCmd(createEditUserCmd(), []string{"U", "--allow-pub-response=100", "--response-ttl", "2ms"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") @@ -337,7 +319,7 @@ func Test_EditUserResponsePermissions2(t *testing.T) { require.NotNil(t, uc.Resp) require.Equal(t, 100, uc.Resp.MaxMsgs) - _, _, err = ExecuteCmd(createEditUserCmd(), "--rm-response-perms") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--rm-response-perms"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") @@ -350,24 +332,24 @@ func Test_EditUserBearerToken(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(CreateAddUserCmd(), "U") + _, err := ExecuteCmd(CreateAddUserCmd(), "U") require.NoError(t, err) u, err := ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) require.False(t, u.BearerToken) - _, stderr, err := ExecuteCmd(createEditUserCmd(), "--name", "U", "--bearer") + out, err := ExecuteCmd(createEditUserCmd(), "--name", "U", "--bearer") require.NoError(t, err) - require.Contains(t, stderr, "changed bearer to true") + require.Contains(t, out.Out, "changed bearer to true") u, err = ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) require.True(t, u.BearerToken) - _, stderr, err = ExecuteCmd(createEditUserCmd(), "--name", "U", "--bearer=false") + out, err = ExecuteCmd(createEditUserCmd(), "--name", "U", "--bearer=false") require.NoError(t, err) - require.Contains(t, stderr, "ignoring change to bearer - value is already false") + require.Contains(t, out.Out, "ignoring change to bearer - value is already false") u, err = ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) @@ -388,7 +370,7 @@ func Test_EditUserWithSigningKeyOnly(t *testing.T) { require.True(t, ts.KeyStore.HasPrivateKey(pk)) ts.AddAccount(t, "A") - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -397,9 +379,9 @@ func Test_EditUserWithSigningKeyOnly(t *testing.T) { require.NoError(t, ts.KeyStore.Remove(ac.Subject)) require.False(t, ts.KeyStore.HasPrivateKey(ac.Subject)) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "AAA") + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "AAA"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), "--name", "AAA", "--payload", "5") + _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), []string{"--name", "AAA", "--payload", "5"}...) require.NoError(t, err) claim, err := ts.Store.ReadUserClaim("A", "AAA") @@ -424,7 +406,7 @@ func Test_EditUserWithSigningKeyInteractive(t *testing.T) { require.True(t, ts.KeyStore.HasPrivateKey(pk)) ts.AddAccount(t, "A") - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -432,13 +414,13 @@ func Test_EditUserWithSigningKeyInteractive(t *testing.T) { require.NotNil(t, ac) require.True(t, ts.KeyStore.HasPrivateKey(ac.Subject)) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "AAA") + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "AAA"}...) require.NoError(t, err) inputs := []interface{}{1, "5", "0", "0", false} cmd := createEditUserCmd() HoistRootFlags(cmd) - _, _, err = ExecuteInteractiveCmd(cmd, inputs, "--name", "AAA") + _, err = ExecuteInteractiveCmd(cmd, inputs, "--name", "AAA") require.NoError(t, err) claim, err := ts.Store.ReadUserClaim("A", "AAA") @@ -461,7 +443,7 @@ func Test_EditUserSk(t *testing.T) { pSk, err := sk.PublicKey() require.NoError(t, err) - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pSk) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pSk}...) require.NoError(t, err) ts.AddUserWithSigner(t, "A", "u", sk) @@ -469,7 +451,7 @@ func Test_EditUserSk(t *testing.T) { require.NoError(t, err) require.Equal(t, uc.Issuer, pSk) - _, _, err = ExecuteCmd(createEditUserCmd(), "--tag", "foo") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--tag", "foo"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "u") require.NoError(t, err) @@ -485,7 +467,7 @@ func Test_EditUserSubs(t *testing.T) { require.NoError(t, err) require.Equal(t, int64(-1), uc.Subs) - _, _, err = ExecuteCmd(createEditUserCmd(), "--subs", "100") + _, err = ExecuteCmd(createEditUserCmd(), []string{"--subs", "100"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) @@ -502,7 +484,7 @@ func Test_EditUserData(t *testing.T) { require.NoError(t, err) require.Equal(t, int64(-1), uc.Limits.Data) - _, _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), "--data", "1Kib") + _, err = ExecuteCmd(HoistRootFlags(createEditUserCmd()), []string{"--data", "1Kib"}...) require.NoError(t, err) uc, err = ts.Store.ReadUserClaim("A", "U") require.NoError(t, err) @@ -516,10 +498,10 @@ func Test_EditUserConnection(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createEditUserCmd(), "--conn-type", "hello") + _, err := ExecuteCmd(createEditUserCmd(), []string{"--conn-type", "hello"}...) require.Error(t, err) - _, _, err = ExecuteCmd(createEditUserCmd(), "--conn-type", jwt.ConnectionTypeInProcess) + _, err = ExecuteCmd(createEditUserCmd(), []string{"--conn-type", jwt.ConnectionTypeInProcess}...) require.NoError(t, err) } @@ -550,7 +532,7 @@ func Test_EditUserConnectionCase(t *testing.T) { require.Len(t, claim.AllowedConnectionTypes, 1) require.Contains(t, claim.AllowedConnectionTypes, strings.ToLower(jwt.ConnectionTypeStandard)) - _, _, err = ExecuteCmd(createEditUserCmd(), "--conn-type", strings.ToLower(jwt.ConnectionTypeMqtt)) + _, err = ExecuteCmd(createEditUserCmd(), []string{"--conn-type", strings.ToLower(jwt.ConnectionTypeMqtt)}...) require.NoError(t, err) claim, err = ts.Store.ReadUserClaim("A", "U") @@ -588,7 +570,7 @@ func Test_EditUserConnectionDeleteCase(t *testing.T) { require.Len(t, claim.AllowedConnectionTypes, 1) require.Contains(t, claim.AllowedConnectionTypes, strings.ToLower(jwt.ConnectionTypeStandard)) - _, _, err = ExecuteCmd(createEditUserCmd(), "--rm-conn-type", jwt.ConnectionTypeStandard) + _, err = ExecuteCmd(createEditUserCmd(), []string{"--rm-conn-type", jwt.ConnectionTypeStandard}...) require.NoError(t, err) claim, err = ts.Store.ReadUserClaim("A", "U") diff --git a/cmd/env_test.go b/cmd/env_test.go index 2f112c3f..4f5a18b3 100644 --- a/cmd/env_test.go +++ b/cmd/env_test.go @@ -32,13 +32,13 @@ func TestEnv_DefaultOutput(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, stderr, err := ExecuteCmd(createEnvCmd()) + out, err := ExecuteCmd(createEnvCmd(), []string{}...) require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stdout := StripTableDecorations(out.Out) require.NoError(t, err) - require.Contains(t, stderr, fmt.Sprintf("$NKEYS_PATH (deprecated) Yes %s", AbbrevHomePaths(store.GetKeysDir()))) - require.Contains(t, stderr, fmt.Sprintf("Current Store Dir %s", AbbrevHomePaths(filepath.Dir(ts.Store.Dir)))) - require.Contains(t, stderr, "Current Operator test") + require.Contains(t, stdout, fmt.Sprintf("$NKEYS_PATH (deprecated) Yes %s", AbbrevHomePaths(store.GetKeysDir()))) + require.Contains(t, stdout, fmt.Sprintf("Current Store Dir %s", AbbrevHomePaths(filepath.Dir(ts.Store.Dir)))) + require.Contains(t, stdout, "Current Operator test") } func TestEnv_SetAccountOutput(t *testing.T) { @@ -48,20 +48,20 @@ func TestEnv_SetAccountOutput(t *testing.T) { ts.AddAccount(t, "A") ts.AddAccount(t, "B") - _, stderr, err := ExecuteCmd(createEnvCmd(), "--operator", "test", "--account", "B") + out, err := ExecuteCmd(createEnvCmd(), []string{"--operator", "test", "--account", "B"}...) require.NoError(t, err) - stderr = StripTableDecorations(stderr) - require.Contains(t, stderr, fmt.Sprintf("$NKEYS_PATH (deprecated) Yes %s", AbbrevHomePaths(store.GetKeysDir()))) - require.Contains(t, stderr, fmt.Sprintf("Current Store Dir %s", AbbrevHomePaths(filepath.Dir(ts.Store.Dir)))) - require.Contains(t, stderr, "Current Operator test") - require.Contains(t, stderr, "Current Account B") + stdout := StripTableDecorations(out.Out) + require.Contains(t, stdout, fmt.Sprintf("$NKEYS_PATH (deprecated) Yes %s", AbbrevHomePaths(store.GetKeysDir()))) + require.Contains(t, stdout, fmt.Sprintf("Current Store Dir %s", AbbrevHomePaths(filepath.Dir(ts.Store.Dir)))) + require.Contains(t, stdout, "Current Operator test") + require.Contains(t, stdout, "Current Account B") } func TestEnv_FailsBadOperator(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(createEnvCmd(), "-o", "X") + _, err := ExecuteCmd(createEnvCmd(), []string{"-o", "X"}...) require.Error(t, err) require.Contains(t, err.Error(), "operator \"X\" not in") } @@ -70,7 +70,7 @@ func TestEnv_FailsBadAccount(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(createEnvCmd(), "-a", "A") + _, err := ExecuteCmd(createEnvCmd(), []string{"-a", "A"}...) require.Error(t, err) require.Contains(t, err.Error(), "\"A\" not in accounts for operator \"O\"") } @@ -79,10 +79,10 @@ func TestAllDir(t *testing.T) { p := MakeTempDir(t) defer os.RemoveAll(p) - _, _, err := ExecuteCmd(rootCmd, "env", "--all-dirs", p) + _, err := ExecuteCmd(rootCmd, []string{"env", "--all-dirs", p}...) require.NoError(t, err) - _, _, err = ExecuteCmd(rootCmd, "add", "operator", "O", "--all-dirs", p) + _, err = ExecuteCmd(rootCmd, []string{"add", "operator", "O", "--all-dirs", p}...) require.NoError(t, err) assert.FileExists(t, path.Join(p, "nsc.json")) diff --git a/cmd/expirations.go b/cmd/expirations.go index 0ef9d33b..b1284c99 100644 --- a/cmd/expirations.go +++ b/cmd/expirations.go @@ -93,7 +93,7 @@ type ExpirationReportJSON struct { Report []*ExpirationReport `json:"report"` } -func (p *ExpirationsParams) renderJSON(_ctx ActionCtx) error { +func (p *ExpirationsParams) renderJSON(ctx ActionCtx) error { r := ExpirationReportJSON{ ExpirationThreshold: time.Unix(p.expirationDuration, 0).Format(time.RFC3339), Report: p.expirationReport, @@ -102,7 +102,7 @@ func (p *ExpirationsParams) renderJSON(_ctx ActionCtx) error { if err != nil { return err } - _, err = os.Stdout.Write(data) + _, err = fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), string(data)) return err } diff --git a/cmd/expirations_test.go b/cmd/expirations_test.go index ca5fe928..e2ba6b5a 100644 --- a/cmd/expirations_test.go +++ b/cmd/expirations_test.go @@ -31,11 +31,11 @@ func Test_ExpirationsNone(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - stdout, _, err := ExecuteCmd(createExpirationsCommand(), "--json") + stdout, err := ExecuteCmd(createExpirationsCommand(), "--json") require.NoError(t, err) var expirations ExpirationReportJSON - err = json.Unmarshal([]byte(stdout), &expirations) + err = json.Unmarshal([]byte(stdout.Out), &expirations) require.NoError(t, err) _, err = time.Parse(time.RFC3339, expirations.ExpirationThreshold) require.NoError(t, err) @@ -55,11 +55,11 @@ func Test_ExpirationsOperator(t *testing.T) { err = ts.Store.StoreRaw([]byte(token)) require.NoError(t, err) - stdout, _, err := ExecuteCmd(createExpirationsCommand(), "--json") + stdout, err := ExecuteCmd(createExpirationsCommand(), []string{"--json"}...) require.NoError(t, err) var expirations ExpirationReportJSON - err = json.Unmarshal([]byte(stdout), &expirations) + err = json.Unmarshal([]byte(stdout.Out), &expirations) require.NoError(t, err) require.Len(t, expirations.Report, 1) require.True(t, expirations.Report[0].Expired) @@ -78,11 +78,11 @@ func Test_ExpirationAccount(t *testing.T) { err = ts.Store.StoreRaw([]byte(token)) require.NoError(t, err) - stdout, _, err := ExecuteCmd(createExpirationsCommand(), "--json") + out, err := ExecuteCmd(createExpirationsCommand(), []string{"--json"}...) require.NoError(t, err) var expirations ExpirationReportJSON - err = json.Unmarshal([]byte(stdout), &expirations) + err = json.Unmarshal([]byte(out.Out), &expirations) require.NoError(t, err) require.Len(t, expirations.Report, 2) require.False(t, expirations.Report[0].Expired) @@ -103,11 +103,11 @@ func Test_ExpirationUser(t *testing.T) { err = ts.Store.StoreRaw([]byte(token)) require.NoError(t, err) - stdout, _, err := ExecuteCmd(createExpirationsCommand(), "--json") + out, err := ExecuteCmd(createExpirationsCommand(), []string{"--json"}...) require.NoError(t, err) var expirations ExpirationReportJSON - err = json.Unmarshal([]byte(stdout), &expirations) + err = json.Unmarshal([]byte(out.Out), &expirations) require.NoError(t, err) require.Len(t, expirations.Report, 4) require.False(t, expirations.Report[0].Expired) @@ -130,11 +130,11 @@ func Test_ExpiresSoonOperator(t *testing.T) { err = ts.Store.StoreRaw([]byte(token)) require.NoError(t, err) - stdout, _, err := ExecuteCmd(createExpirationsCommand(), "--json") + out, err := ExecuteCmd(createExpirationsCommand(), []string{"--json"}...) require.NoError(t, err) var expirations ExpirationReportJSON - err = json.Unmarshal([]byte(stdout), &expirations) + err = json.Unmarshal([]byte(out.Out), &expirations) require.NoError(t, err) require.Len(t, expirations.Report, 1) require.False(t, expirations.Report[0].Expired) @@ -154,11 +154,11 @@ func Test_ExpiresSoonAccount(t *testing.T) { err = ts.Store.StoreRaw([]byte(token)) require.NoError(t, err) - stdout, _, err := ExecuteCmd(createExpirationsCommand(), "--json") + out, err := ExecuteCmd(createExpirationsCommand(), []string{"--json"}...) require.NoError(t, err) var expirations ExpirationReportJSON - err = json.Unmarshal([]byte(stdout), &expirations) + err = json.Unmarshal([]byte(out.Out), &expirations) require.NoError(t, err) require.Len(t, expirations.Report, 2) require.False(t, expirations.Report[0].Expired) @@ -185,11 +185,11 @@ func Test_ExpiresSoonUser(t *testing.T) { _, err = ts.KeyStore.MaybeStoreUserCreds("A", "U", creds) require.NoError(t, err) - stdout, _, err := ExecuteCmd(createExpirationsCommand(), "--json") + out, err := ExecuteCmd(createExpirationsCommand(), []string{"--json"}...) require.NoError(t, err) var expirations ExpirationReportJSON - err = json.Unmarshal([]byte(stdout), &expirations) + err = json.Unmarshal([]byte(out.Out), &expirations) require.NoError(t, err) require.Len(t, expirations.Report, 4) require.False(t, expirations.Report[0].Expired) @@ -200,9 +200,9 @@ func Test_ExpiresSoonUser(t *testing.T) { require.True(t, expirations.Report[3].ExpiresSoon) require.False(t, expirations.Report[3].Expired) - stdout, _, err = ExecuteCmd(createExpirationsCommand(), "--skip", "--json") + out, err = ExecuteCmd(createExpirationsCommand(), []string{"--skip", "--json"}...) require.NoError(t, err) - err = json.Unmarshal([]byte(stdout), &expirations) + err = json.Unmarshal([]byte(out.Out), &expirations) require.NoError(t, err) require.Len(t, expirations.Report, 2) require.Equal(t, expirations.Report[0].ID, uc.Subject) @@ -227,12 +227,12 @@ func Test_ExpirationsTable(t *testing.T) { err = ts.Store.StoreRaw([]byte(token)) require.NoError(t, err) - _, stderr, err := ExecuteCmd(createExpirationsCommand()) + out, err := ExecuteCmd(createExpirationsCommand()) require.NoError(t, err) - require.Contains(t, stderr, "| O") - require.Contains(t, stderr, "| O/A") - require.Contains(t, stderr, "| Soon | O/A/U") - require.Contains(t, stderr, "In 59 Minutes |") - require.Contains(t, stderr, filepath.FromSlash("creds/O/A/U.creds")) + require.Contains(t, out.Out, "| O") + require.Contains(t, out.Out, "| O/A") + require.Contains(t, out.Out, "| Soon | O/A/U") + require.Contains(t, out.Out, "In 59 Minutes |") + require.Contains(t, out.Out, filepath.FromSlash("creds/O/A/U.creds")) } diff --git a/cmd/exportkeys_test.go b/cmd/exportkeys_test.go index 58f8b9e6..879b00f4 100644 --- a/cmd/exportkeys_test.go +++ b/cmd/exportkeys_test.go @@ -58,7 +58,7 @@ func Test_ExportContext(t *testing.T) { ts.AddUser(t, "A", "U") exportDir := filepath.Join(ts.Dir, "export") - _, _, err := ExecuteCmd(createExportKeysCmd(), "--dir", exportDir) + _, err := ExecuteCmd(createExportKeysCmd(), []string{"--dir", exportDir}...) require.NoError(t, err) opk := ts.GetOperatorPublicKey(t) @@ -80,7 +80,7 @@ func Test_ExportOnlyContext(t *testing.T) { ts.AddUser(t, "A", "U") exportDir := filepath.Join(ts.Dir, "export") - _, _, err := ExecuteCmd(createExportKeysCmd(), "--dir", exportDir) + _, err := ExecuteCmd(createExportKeysCmd(), []string{"--dir", exportDir}...) require.NoError(t, err) opk := ts.GetOperatorPublicKey(t) @@ -108,7 +108,7 @@ func Test_ExportAllContext(t *testing.T) { ts.AddUser(t, "A", "U") upk := ts.GetUserPublicKey(t, "AA", "UU") - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--account", "AA", "--auth-user", upk, "--curve", "generate") + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--account", "AA", "--auth-user", upk, "--curve", "generate"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("AA") @@ -117,7 +117,7 @@ func Test_ExportAllContext(t *testing.T) { exportDir := filepath.Join(ts.Dir, "export") - _, _, err = ExecuteCmd(createExportKeysCmd(), "--all", "--dir", exportDir) + _, err = ExecuteCmd(createExportKeysCmd(), []string{"--all", "--dir", exportDir}...) require.NoError(t, err) opk := ts.GetOperatorPublicKey(t) @@ -146,7 +146,7 @@ func Test_ExportAccount(t *testing.T) { ts.AddUser(t, "A", "U") exportDir := filepath.Join(ts.Dir, "export") - _, _, err := ExecuteCmd(createExportKeysCmd(), "--account", "AA", "--dir", exportDir) + _, err := ExecuteCmd(createExportKeysCmd(), []string{"--account", "AA", "--dir", exportDir}...) require.NoError(t, err) opk := ts.GetOperatorPublicKey(t) @@ -176,7 +176,7 @@ func Test_ExportRemove(t *testing.T) { upk := ts.GetUserPublicKey(t, "A", "U") exportDir := filepath.Join(ts.Dir, "export") - _, _, err := ExecuteCmd(createExportKeysCmd(), "--dir", exportDir, "--remove") + _, err := ExecuteCmd(createExportKeysCmd(), []string{"--dir", exportDir, "--remove"}...) require.NoError(t, err) requireExportedKey(t, exportDir, opk) @@ -193,7 +193,7 @@ func Test_ExportNoKeyStore(t *testing.T) { defer ts.Done(t) store.KeyStorePath = ts.KeysDir - _, _, err := ExecuteCmd(createExportKeysCmd(), "--dir", ts.Dir) + _, err := ExecuteCmd(createExportKeysCmd(), []string{"--dir", ts.Dir}...) require.Error(t, err) require.Equal(t, err.Error(), fmt.Sprintf("keystore `%s` does not exist", ts.KeysDir)) } @@ -206,7 +206,7 @@ func Test_ExportXKeyNotReferenced(t *testing.T) { _, xPK, kp := CreateCurveKey(t) ts.KeyStore.Store(kp) - _, _, err := ExecuteCmd(createExportKeysCmd(), "--dir", exportDir, "--curve", xPK, "--not-referenced") + _, err := ExecuteCmd(createExportKeysCmd(), []string{"--dir", exportDir, "--curve", xPK, "--not-referenced"}...) require.NoError(t, err) requireExportedKey(t, exportDir, xPK) } @@ -217,7 +217,7 @@ func Test_ExportXKeyInContext(t *testing.T) { ts.AddAccount(t, "A") _, uPK, _ := CreateUserKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--auth-user", uPK, "--curve", "generate") + _, err := ExecuteCmd(createEditAuthorizationCallout(), []string{"--auth-user", uPK, "--curve", "generate"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -226,12 +226,12 @@ func Test_ExportXKeyInContext(t *testing.T) { require.NotEmpty(t, xPK) exportDir := filepath.Join(ts.Dir, "export") - _, _, err = ExecuteCmd(createExportKeysCmd(), "--dir", exportDir, "--curves") + _, err = ExecuteCmd(createExportKeysCmd(), []string{"--dir", exportDir, "--curves"}...) require.NoError(t, err) requireExportedKey(t, exportDir, xPK) exportDir = filepath.Join(ts.Dir, "export2") - _, _, err = ExecuteCmd(createExportKeysCmd(), "--dir", exportDir, "-A") + _, err = ExecuteCmd(createExportKeysCmd(), []string{"--dir", exportDir, "-A"}...) require.NoError(t, err) requireExportedKey(t, exportDir, xPK) } @@ -248,7 +248,7 @@ func Test_ExportKeyJwt(t *testing.T) { u := ts.GetUserPublicKey(t, "A", "U") exportDir := filepath.Join(ts.Dir, "export") - _, _, err := ExecuteCmd(createExportKeysCmd(), "--dir", exportDir, "-A", "--include-jwts") + _, err := ExecuteCmd(createExportKeysCmd(), []string{"--dir", exportDir, "-A", "--include-jwts"}...) require.NoError(t, err) requireExportedKey(t, exportDir, o) require.FileExists(t, filepath.Join(exportDir, fmt.Sprintf("%s.jwt", o))) diff --git a/cmd/fixenv_test.go b/cmd/fixenv_test.go index 62d33c6c..9fedc23d 100644 --- a/cmd/fixenv_test.go +++ b/cmd/fixenv_test.go @@ -26,7 +26,7 @@ import ( ) func Test_FixRequiresInArg(t *testing.T) { - _, _, err := ExecuteCmd(createFixCmd()) + _, err := ExecuteCmd(createFixCmd(), []string{}...) require.Error(t, err) } @@ -37,7 +37,7 @@ func Test_NoOperatorsErr(t *testing.T) { fp := filepath.Join(ts.Dir, "in") require.NoError(t, MaybeMakeDir(fp)) - _, _, err := ExecuteCmd(createFixCmd(), "--in", fp) + _, err := ExecuteCmd(createFixCmd(), []string{"--in", fp}...) require.Error(t, err) } @@ -49,9 +49,9 @@ func Test_FixBasics(t *testing.T) { require.NoError(t, MaybeMakeDir(in)) osk, opk, okp := CreateOperatorKey(t) - require.NoError(t, Write(filepath.Join(in, "opk.nk"), osk)) + require.NoError(t, WriteFile(filepath.Join(in, "opk.nk"), osk)) oss, ospk, _ := CreateOperatorKey(t) - require.NoError(t, Write(filepath.Join(in, "ospk.nk"), oss)) + require.NoError(t, WriteFile(filepath.Join(in, "ospk.nk"), oss)) // save one version oc := jwt.NewOperatorClaims(opk) @@ -59,23 +59,23 @@ func Test_FixBasics(t *testing.T) { oc.SigningKeys.Add(ospk) otok, err := oc.Encode(okp) require.NoError(t, err) - require.NoError(t, Write(filepath.Join(in, "o.jwt"), []byte(otok))) + require.NoError(t, WriteFile(filepath.Join(in, "o.jwt"), []byte(otok))) ask, apk, akp := CreateAccountKey(t) - require.NoError(t, Write(filepath.Join(in, "apk.nk"), ask)) + require.NoError(t, WriteFile(filepath.Join(in, "apk.nk"), ask)) ac := jwt.NewAccountClaims(apk) ac.Name = "A" atok, err := ac.Encode(okp) require.NoError(t, err) - require.NoError(t, Write(filepath.Join(in, "a.jwt"), []byte(atok))) + require.NoError(t, WriteFile(filepath.Join(in, "a.jwt"), []byte(atok))) usk, upk, _ := CreateUserKey(t) - require.NoError(t, Write(filepath.Join(in, "upk.nk"), usk)) + require.NoError(t, WriteFile(filepath.Join(in, "upk.nk"), usk)) uc := jwt.NewUserClaims(upk) uc.Name = "U" utok, err := uc.Encode(akp) require.NoError(t, err) - require.NoError(t, Write(filepath.Join(in, "u.jwt"), []byte(utok))) + require.NoError(t, WriteFile(filepath.Join(in, "u.jwt"), []byte(utok))) usk2, upk2, _ := CreateUserKey(t) uc2 := jwt.NewUserClaims(upk2) @@ -84,7 +84,7 @@ func Test_FixBasics(t *testing.T) { require.NoError(t, err) creds, err := jwt.FormatUserConfig(u2tok, usk2) require.NoError(t, err) - require.NoError(t, Write(filepath.Join(in, "u2.creds"), creds)) + require.NoError(t, WriteFile(filepath.Join(in, "u2.creds"), creds)) // and copy of operator with a tag (and newer date) time.Sleep(time.Second) @@ -92,20 +92,20 @@ func Test_FixBasics(t *testing.T) { oc.Tags.Add("test") otok2, err := oc.Encode(okp) require.NoError(t, err) - require.NoError(t, Write(filepath.Join(in, "o2.jwt"), []byte(otok2))) + require.NoError(t, WriteFile(filepath.Join(in, "o2.jwt"), []byte(otok2))) ac.Tags.Add("test") atok, err = ac.Encode(okp) require.NoError(t, err) - require.NoError(t, Write(filepath.Join(in, "a2.jwt"), []byte(atok))) + require.NoError(t, WriteFile(filepath.Join(in, "a2.jwt"), []byte(atok))) uc.Tags.Add("test") utok, err = uc.Encode(akp) require.NoError(t, err) - require.NoError(t, Write(filepath.Join(in, "u2.jwt"), []byte(utok))) + require.NoError(t, WriteFile(filepath.Join(in, "u2.jwt"), []byte(utok))) ofp := filepath.Join(ts.Dir, "out") - _, _, err = ExecuteCmd(createFixCmd(), "--creds", "--in", in, "--out", ofp) + _, err = ExecuteCmd(createFixCmd(), []string{"--creds", "--in", in, "--out", ofp}...) require.NoError(t, err) s, err := store.LoadStore(filepath.Join(ofp, "operators", "O")) diff --git a/cmd/generateactivation.go b/cmd/generateactivation.go index 1426f7c8..a54eced1 100644 --- a/cmd/generateactivation.go +++ b/cmd/generateactivation.go @@ -259,14 +259,17 @@ func (p *GenerateActivationParams) Run(ctx ActionCtx) (store.Status, error) { // if some command embeds, the output will be blank // in that case don't generate the output if p.out != "" { - if err := Write(p.out, d); err != nil { - return nil, err - } if !IsStdOut(p.out) { + if err := WriteFile(p.out, d); err != nil { + return nil, err + } r.AddOK("wrote activation token to %#q", AbbrevHomePaths(p.out)) + } else { + if _, err := fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), string(d)); err != nil { + return nil, err + } } } - if p.push { oc, err := ctx.StoreCtx().Store.ReadOperatorClaim() if err != nil { diff --git a/cmd/generateactivation_test.go b/cmd/generateactivation_test.go index c4bce0f1..bab64496 100644 --- a/cmd/generateactivation_test.go +++ b/cmd/generateactivation_test.go @@ -71,7 +71,7 @@ func Test_GenerateActivationMultipleAccountRequired(t *testing.T) { ts.AddExport(t, "A", jwt.Stream, "bar.>", 0, false) ts.AddAccount(t, "B") GetConfig().SetAccount("") - _, _, err := ExecuteCmd(createGenerateActivationCmd()) + _, err := ExecuteCmd(createGenerateActivationCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "account is required") } @@ -81,7 +81,7 @@ func Test_GenerateActivationEmptyExports(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createGenerateActivationCmd()) + _, err := ExecuteCmd(createGenerateActivationCmd(), []string{}...) require.Error(t, err) require.Equal(t, "account \"A\" doesn't have exports", err.Error()) } @@ -93,7 +93,7 @@ func Test_GenerateActivationNoPrivateExports(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "foo", 0, true) - _, _, err := ExecuteCmd(createGenerateActivationCmd()) + _, err := ExecuteCmd(createGenerateActivationCmd(), []string{}...) require.Error(t, err) require.Equal(t, "account \"A\" doesn't have exports that require an activation token", err.Error()) } @@ -108,7 +108,7 @@ func Test_GenerateActivationOutputsFile(t *testing.T) { _, pub, _ := CreateAccountKey(t) outpath := filepath.Join(ts.Dir, "token.jwt") - _, _, err := ExecuteCmd(createGenerateActivationCmd(), "--target-account", pub, "--output-file", outpath) + _, err := ExecuteCmd(createGenerateActivationCmd(), []string{"--target-account", pub, "--output-file", outpath}...) require.NoError(t, err) testExternalToken(t, outpath) } @@ -123,7 +123,7 @@ func Test_GenerateActivationTargetAccountByName(t *testing.T) { ts.AddAccount(t, "B") outpath := filepath.Join(ts.Dir, "token.jwt") - _, _, err := ExecuteCmd(createGenerateActivationCmd(), "-a", "A", "--target-account", "B", "--output-file", outpath) + _, err := ExecuteCmd(createGenerateActivationCmd(), []string{"-a", "A", "--target-account", "B", "--output-file", outpath}...) require.NoError(t, err) ac := testExternalToken(t, outpath) @@ -166,7 +166,7 @@ func Test_InteractiveGenerate(t *testing.T) { outpath := filepath.Join(ts.Dir, "token.jwt") inputs := []interface{}{0, "foo", pub, "0", "0"} - _, _, err := ExecuteInteractiveCmd(cmd, inputs, "-i", "--output-file", outpath) + _, err := ExecuteInteractiveCmd(cmd, inputs, "-i", "--output-file", outpath) require.NoError(t, err) testExternalToken(t, outpath) @@ -187,7 +187,7 @@ func Test_InteractiveExternalKeyGenerate(t *testing.T) { _, pub, _ := CreateAccountKey(t) inputs := []interface{}{0, "foo", pub, "0", "0"} - _, _, err := ExecuteInteractiveCmd(cmd, inputs, "-i", "--output-file", outpath) + _, err := ExecuteInteractiveCmd(cmd, inputs, "-i", "--output-file", outpath) require.NoError(t, err) testExternalToken(t, outpath) @@ -208,7 +208,7 @@ func Test_InteractiveMultipleAccountsGenerate(t *testing.T) { _, pub, _ := CreateAccountKey(t) inputs := []interface{}{0, 0, "foo", pub, "0", "0"} - _, _, err := ExecuteInteractiveCmd(cmd, inputs, "-i", "--output-file", outpath) + _, err := ExecuteInteractiveCmd(cmd, inputs, "-i", "--output-file", outpath) require.NoError(t, err) testExternalToken(t, outpath) @@ -221,13 +221,13 @@ func Test_GenerateActivationUsingSigningKey(t *testing.T) { ts.AddAccount(t, "A") sk, pk, _ := CreateAccountKey(t) ts.AddExport(t, "A", jwt.Stream, "foo", 0, false) - _, _, err := ExecuteCmd(createEditAccount(), "--sk", pk) + _, err := ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) _, tpk, _ := CreateAccountKey(t) outpath := filepath.Join(ts.Dir, "token.jwt") - _, _, err = ExecuteCmd(HoistRootFlags(createGenerateActivationCmd()), "-t", tpk, "-s", "foo", "-o", outpath, "-K", string(sk)) + _, err = ExecuteCmd(HoistRootFlags(createGenerateActivationCmd()), []string{"-t", tpk, "-s", "foo", "-o", outpath, "-K", string(sk)}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -262,7 +262,7 @@ func Test_InteractiveGenerateActivationPush(t *testing.T) { tf := filepath.Join(ts.Dir, "token.jwt") inputs := []interface{}{0, "q", apk, "0", "0", true} - _, _, err = ExecuteInteractiveCmd(createGenerateActivationCmd(), inputs, "--output-file", tf) + _, err = ExecuteInteractiveCmd(createGenerateActivationCmd(), inputs, []string{"--output-file", tf}...) require.NoError(t, err) d, err := Read(tf) diff --git a/cmd/generatecontext_test.go b/cmd/generatecontext_test.go index 924ebc85..6bcd6ce0 100644 --- a/cmd/generatecontext_test.go +++ b/cmd/generatecontext_test.go @@ -35,7 +35,7 @@ func Test_GenerateContext(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createGenerateContext(), "-a", "A", "-u", "U", "--context", "u") + _, err := ExecuteCmd(createGenerateContext(), []string{"-a", "A", "-u", "U", "--context", "u"}...) require.NoError(t, err) fp := filepath.Join(ts.Dir, "nats", "context", "u.json") diff --git a/cmd/generatecreds.go b/cmd/generatecreds.go index 34da395b..639f4e28 100644 --- a/cmd/generatecreds.go +++ b/cmd/generatecreds.go @@ -144,8 +144,13 @@ func (p *GenerateCredsParams) Run(ctx ActionCtx) (store.Status, error) { if err != nil { return nil, err } - if err := Write(p.out, d); err != nil { - return nil, err + if IsStdOut(p.out) { + _, err = fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), string(d)) + } else { + err = WriteFile(p.out, d) + } + if err != nil { + return nil, nil } var s store.Status if !IsStdOut(p.out) { diff --git a/cmd/generatecreds_test.go b/cmd/generatecreds_test.go index 8db8f7b0..1bd9c862 100644 --- a/cmd/generatecreds_test.go +++ b/cmd/generatecreds_test.go @@ -16,13 +16,11 @@ package cmd import ( - "os" - "testing" - "github.com/nats-io/jwt/v2" - "github.com/nats-io/nsc/v2/cmd/store" "github.com/stretchr/testify/require" + "os" + "testing" ) func TestGenerateConfig_Default(t *testing.T) { @@ -38,10 +36,10 @@ func TestGenerateConfig_Default(t *testing.T) { seed := ts.GetUserSeedKey(t, "A", "u") require.NoError(t, err) - stdout, _, err := ExecuteCmd(createGenerateCredsCmd()) + out, err := ExecuteCmd(createGenerateCredsCmd()) require.NoError(t, err) - require.Contains(t, stdout, string(accountJwt)) - require.Contains(t, stdout, seed) + require.Contains(t, out.Out, string(accountJwt)) + require.Contains(t, out.Out, seed) } func TestGenerateConfig_MultipleAccounts(t *testing.T) { @@ -59,10 +57,10 @@ func TestGenerateConfig_MultipleAccounts(t *testing.T) { seed := ts.GetUserSeedKey(t, "A", "u") require.NoError(t, err) - stdout, _, err := ExecuteCmd(createGenerateCredsCmd()) + out, err := ExecuteCmd(createGenerateCredsCmd(), []string{}...) require.NoError(t, err) - require.Contains(t, stdout, string(accountJwt)) - require.Contains(t, stdout, seed) + require.Contains(t, out.Out, string(accountJwt)) + require.Contains(t, out.Out, seed) } func TestGenerateConfig_MultipleAccountsAccountRequired(t *testing.T) { @@ -75,7 +73,7 @@ func TestGenerateConfig_MultipleAccountsAccountRequired(t *testing.T) { ts.AddUser(t, "B", "u") GetConfig().SetAccount("") - _, _, err := ExecuteCmd(createGenerateCredsCmd()) + _, err := ExecuteCmd(createGenerateCredsCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "account is required") } @@ -94,14 +92,14 @@ func TestGenerateConfig_MultipleUsers(t *testing.T) { seed := ts.GetUserSeedKey(t, "A", "u") require.NoError(t, err) - _, _, err = ExecuteCmd(createGenerateCredsCmd()) + _, err = ExecuteCmd(createGenerateCredsCmd(), []string{}...) require.Error(t, err) require.Equal(t, "user is required", err.Error()) - stdout, _, err := ExecuteCmd(createGenerateCredsCmd(), "--account", "A", "--name", "u") + stdout, err := ExecuteCmd(createGenerateCredsCmd(), []string{"--account", "A", "--name", "u"}...) require.NoError(t, err) - require.Contains(t, stdout, string(accountJwt)) - require.Contains(t, stdout, seed) + require.Contains(t, stdout.Out, string(accountJwt)) + require.Contains(t, stdout.Out, seed) } func TestGenerateConfig_Interactive(t *testing.T) { @@ -117,10 +115,10 @@ func TestGenerateConfig_Interactive(t *testing.T) { require.NoError(t, err) seed := ts.GetUserSeedKey(t, "A", "u") - stdout, _, err := ExecuteInteractiveCmd(createGenerateCredsCmd(), []interface{}{0, 0}) + stdout, err := ExecuteInteractiveCmd(createGenerateCredsCmd(), []interface{}{0, 0}) require.NoError(t, err) - require.Contains(t, stdout, string(accountJwt)) - require.Contains(t, stdout, seed) + require.Contains(t, stdout.Out, string(accountJwt)) + require.Contains(t, stdout.Out, seed) } func TestGenerateConfig_HonorsAccount(t *testing.T) { @@ -132,18 +130,18 @@ func TestGenerateConfig_HonorsAccount(t *testing.T) { ts.AddAccount(t, "B") ts.AddUser(t, "B", "bu") - stdout, _, err := ExecuteCmd(createGenerateCredsCmd(), "--account", "A") + out, err := ExecuteCmd(createGenerateCredsCmd(), []string{"--account", "A"}...) require.NoError(t, err) - userToken, err := jwt.ParseDecoratedJWT([]byte(stdout)) + userToken, err := jwt.ParseDecoratedJWT([]byte(out.Out)) require.NoError(t, err) uc, err := jwt.DecodeUserClaims(userToken) require.NoError(t, err) require.Equal(t, "au", uc.Name) - stdout, _, err = ExecuteCmd(createGenerateCredsCmd(), "--account", "B") + out, err = ExecuteCmd(createGenerateCredsCmd(), []string{"--account", "B"}...) require.NoError(t, err) - userToken, err = jwt.ParseDecoratedJWT([]byte(stdout)) + userToken, err = jwt.ParseDecoratedJWT([]byte(out.Out)) require.NoError(t, err) uc, err = jwt.DecodeUserClaims(userToken) @@ -163,9 +161,9 @@ func TestGenerateConfig_InteractiveHonorsAccount(t *testing.T) { t.Log(os.Args[0]) inputs := []interface{}{0} - stdout, _, err := ExecuteInteractiveCmd(createGenerateCredsCmd(), inputs) + stdout, err := ExecuteInteractiveCmd(createGenerateCredsCmd(), inputs) require.NoError(t, err) - userToken, err := jwt.ParseDecoratedJWT([]byte(stdout)) + userToken, err := jwt.ParseDecoratedJWT([]byte(stdout.Out)) require.NoError(t, err) uc, err := jwt.DecodeUserClaims(userToken) diff --git a/cmd/generatediagram.go b/cmd/generatediagram.go index d7ce746c..bf32bf46 100644 --- a/cmd/generatediagram.go +++ b/cmd/generatediagram.go @@ -16,8 +16,9 @@ package cmd import ( + "bufio" + "bytes" "fmt" - "os" "strings" "time" @@ -49,7 +50,7 @@ func createComponentDiagreamCmd() *cobra.Command { SilenceUsage: true, Example: `nsc generate diagram component`, RunE: func(cmd *cobra.Command, args []string) error { - return componentDiagram(accDetail) + return componentDiagram(cmd, accDetail) }, } cmd.Flags().BoolVarP(&accDetail, "detail", "", false, "Include account descriptions") @@ -66,7 +67,7 @@ func createObjectDiagramCmd() *cobra.Command { SilenceUsage: true, Example: `nsc generate diagram object`, RunE: func(cmd *cobra.Command, args []string) error { - return objectDiagram(users, showKeys, detail) + return objectDiagram(cmd, users, showKeys, detail) }, } @@ -139,7 +140,7 @@ func impSubj(i *jwt.Import) (local string, remote string) { return } -func componentDiagram(accDetail bool) error { +func componentDiagram(cmd *cobra.Command, accDetail bool) error { s, err := GetStore() if err != nil { return err @@ -148,12 +149,8 @@ func componentDiagram(accDetail bool) error { if err != nil { return err } - f := os.Stdout - if !IsStdOut(outputFile) { - if f, err = os.Create(outputFile); err != nil { - return err - } - } + var b bytes.Buffer + f := bufio.NewWriter(&b) bldrPrntf := func(format string, args ...interface{}) { fmt.Fprintln(f, fmt.Sprintf(format, args...)) } @@ -280,10 +277,18 @@ skinparam interface { bldrPrntf(`footer generated by nsc - store dir: %s - date: %s `, s.Dir, time.Now().Format("2006-01-02 15:04:05")) bldrPrntf("@enduml") - return f.Close() + _ = f.Flush() + if IsStdOut(outputFile) { + if _, err := fmt.Fprintln(cmd.OutOrStdout(), b.String()); err != nil { + return err + } + } else { + return WriteFile(outputFile, b.Bytes()) + } + return nil } -func objectDiagram(users bool, showKeys bool, detail bool) error { +func objectDiagram(cmd *cobra.Command, users bool, showKeys bool, detail bool) error { s, err := GetStore() if err != nil { return err @@ -296,14 +301,14 @@ func objectDiagram(users bool, showKeys bool, detail bool) error { if err != nil { return err } - f := os.Stdout - if !IsStdOut(outputFile) { - if f, err = os.Create(outputFile); err != nil { - return err - } - } + var b bytes.Buffer + f := bufio.NewWriter(&b) + bldrPrntf := func(format string, args ...interface{}) { - fmt.Fprintln(f, fmt.Sprintf(format, args...)) + _, err := fmt.Fprintln(f, fmt.Sprintf(format, args...)) + if err != nil { + panic(err) + } } addNote := func(ref string, i jwt.Info) { if i.Description != "" || i.InfoURL != "" { @@ -560,6 +565,12 @@ func objectDiagram(users bool, showKeys bool, detail bool) error { } bldrPrntf(`footer generated by nsc - store dir: %s - date: %s `, s.Dir, time.Now().Format("2006-01-02 15:04:05")) bldrPrntf("@enduml") + _ = f.Flush() - return f.Close() + if !IsStdOut(outputFile) { + return WriteFile(outputFile, b.Bytes()) + } else { + _, err = fmt.Fprintln(cmd.OutOrStdout(), b.String()) + return err + } } diff --git a/cmd/generatediagram_test.go b/cmd/generatediagram_test.go index 9a8800cb..e336a36b 100644 --- a/cmd/generatediagram_test.go +++ b/cmd/generatediagram_test.go @@ -1,11 +1,10 @@ package cmd import ( - "runtime" - "testing" - "github.com/nats-io/jwt/v2" "github.com/stretchr/testify/require" + "runtime" + "testing" ) func buildDiagreamStore(t *testing.T, ts *TestStore) { @@ -50,14 +49,14 @@ func Test_ObjectDiagram(t *testing.T) { defer ts.Done(t) buildDiagreamStore(t, ts) - stdOut, _, err := ExecuteCmd(createObjectDiagramCmd(), "--show-keys", "--users", "--detail") + out, err := ExecuteCmd(createObjectDiagramCmd(), "--show-keys", "--users", "--detail") require.NoError(t, err) - require.Contains(t, stdOut, "@startuml") - require.Contains(t, stdOut, "object \"O\" as") - require.Contains(t, stdOut, "object \"A\" as") - require.Contains(t, stdOut, "object \"B\" as") - require.Contains(t, stdOut, "object \"b\" as") - require.Contains(t, stdOut, "@enduml") + require.Contains(t, out.Out, "@startuml") + require.Contains(t, out.Out, "object \"O\" as") + require.Contains(t, out.Out, "object \"A\" as") + require.Contains(t, out.Out, "object \"B\" as") + require.Contains(t, out.Out, "object \"b\" as") + require.Contains(t, out.Out, "@enduml") } func Test_ComponentDiagram(t *testing.T) { @@ -68,14 +67,14 @@ func Test_ComponentDiagram(t *testing.T) { defer ts.Done(t) buildDiagreamStore(t, ts) - stdOut, _, err := ExecuteCmd(createComponentDiagreamCmd(), "--detail") + out, err := ExecuteCmd(createComponentDiagreamCmd(), []string{"--detail"}...) require.NoError(t, err) - require.Contains(t, stdOut, "@startuml") - require.Contains(t, stdOut, "Component Diagram of Accounts - Operator O") - require.Contains(t, stdOut, "component [A]") - require.Contains(t, stdOut, "component [B]") - require.Contains(t, stdOut, "\"a\" << public stream >>") - require.Contains(t, stdOut, "\"q\" << public service >>") - require.Contains(t, stdOut, "@enduml") + require.Contains(t, out.Out, "@startuml") + require.Contains(t, out.Out, "Component Diagram of Accounts - Operator O") + require.Contains(t, out.Out, "component [A]") + require.Contains(t, out.Out, "component [B]") + require.Contains(t, out.Out, "\"a\" << public stream >>") + require.Contains(t, out.Out, "\"q\" << public service >>") + require.Contains(t, out.Out, "@enduml") } diff --git a/cmd/generatenkey.go b/cmd/generatenkey.go index ae753c7c..8e466d8a 100644 --- a/cmd/generatenkey.go +++ b/cmd/generatenkey.go @@ -82,9 +82,6 @@ func (e *KP) kind() string { func (e *KP) Generate() error { var err error e.kp, err = nkeys.CreatePair(e.prefix) - if err != nil { - panic(err) - } return err } @@ -152,7 +149,7 @@ func (p *GenerateNKeysParam) Run(ctx ActionCtx) (store.Status, error) { return nil, err } } - ctx.CurrentCmd().Println(j.String(p.store)) + _, _ = fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), j.String(p.store)) } } return nil, nil diff --git a/cmd/generatenkey_test.go b/cmd/generatenkey_test.go index bc40033a..41479b7c 100644 --- a/cmd/generatenkey_test.go +++ b/cmd/generatenkey_test.go @@ -28,9 +28,9 @@ func Test_GenerateOperatorNKey(t *testing.T) { ts := NewTestStore(t, "X") defer ts.Done(t) - _, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator") + out, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator") require.NoError(t, err) - lines := strings.Split(stderr, "\n") + lines := strings.Split(out.Out, "\n") require.True(t, len(lines) >= 2) // seed @@ -52,9 +52,9 @@ func Test_GenerateNKeyAndStoreDoesntPrint(t *testing.T) { ts := NewTestStore(t, "X") defer ts.Done(t) - _, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator", "--store") + out, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator", "--store") require.NoError(t, err) - lines := strings.Split(stderr, "\n") + lines := strings.Split(out.Out, "\n") require.True(t, len(lines) == 4) require.Equal(t, lines[2], "") require.Equal(t, lines[3], "") @@ -102,9 +102,9 @@ func Test_GenerateAccountNKey(t *testing.T) { ts := NewTestStore(t, "X") defer ts.Done(t) - _, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--account") + out, err := ExecuteCmd(createGenerateNKeyCmd(), "--account") require.NoError(t, err) - lines := strings.Split(stderr, "\n") + lines := strings.Split(out.Out, "\n") require.True(t, len(lines) >= 2) // seed @@ -126,9 +126,9 @@ func Test_GenerateUserNKey(t *testing.T) { ts := NewTestStore(t, "X") defer ts.Done(t) - _, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--user") + out, err := ExecuteCmd(createGenerateNKeyCmd(), "--user") require.NoError(t, err) - lines := strings.Split(stderr, "\n") + lines := strings.Split(out.Out, "\n") require.True(t, len(lines) >= 2) // seed @@ -150,9 +150,9 @@ func Test_GenerateAllNKeys(t *testing.T) { ts := NewTestStore(t, "X") defer ts.Done(t) - _, stderr, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator", "--account", "--user") + out, err := ExecuteCmd(createGenerateNKeyCmd(), "--operator", "--account", "--user") require.NoError(t, err) - lines := strings.Split(stderr, "\n") + lines := strings.Split(out.Out, "\n") require.True(t, len(lines) > 9) kp, err := nkeys.FromSeed([]byte(lines[0])) diff --git a/cmd/generateprofile_test.go b/cmd/generateprofile_test.go index dbdf48ad..b2cf2e68 100644 --- a/cmd/generateprofile_test.go +++ b/cmd/generateprofile_test.go @@ -118,7 +118,7 @@ func Test_ProfileIDs(t *testing.T) { u := ts.GetUserPublicKey(t, "A", "U") out := path.Join(ts.Dir, "out.json") - _, _, err := ExecuteCmd(createProfileCmd(), "-o", out, "nsc://O/A/U?keys&names") + _, err := ExecuteCmd(createProfileCmd(), []string{"-o", out, "nsc://O/A/U?keys&names"}...) require.NoError(t, err) r := loadResults(t, out) @@ -154,7 +154,7 @@ func Test_ProfileSeedIDs(t *testing.T) { out := path.Join(ts.Dir, "out.json") nu := fmt.Sprintf("nsc://O/A/U?operatorSeed=%s", opk) - _, _, err = ExecuteCmd(createProfileCmd(), "-o", out, nu) + _, err = ExecuteCmd(createProfileCmd(), []string{"-o", out, nu}...) require.NoError(t, err) r := loadResults(t, out) @@ -177,19 +177,19 @@ func Test_ProfileStoreAndKeysDir(t *testing.T) { ts2.AddAccount(t, "AA") ts2.AddUser(t, "AA", "UU") - stdout, _, err := ExecuteCmd(rootCmd, "describe", "operator", "--raw") + out, err := ExecuteCmd(rootCmd, "describe", "operator", "--raw") require.NoError(t, err) - ojwt, err := jwt.DecodeOperatorClaims(stdout) + ojwt, err := jwt.DecodeOperatorClaims(out.Out) require.NoError(t, err) require.Equal(t, "OO", ojwt.Name) - out := path.Join(ts.Dir, "out.json") + fp := path.Join(ts.Dir, "out.json") u := fmt.Sprintf("nsc://O/A/U?names&keys&store=%s&keyStore=%s", ts.StoreDir, ts.KeysDir) - _, _, err = ExecuteCmd(rootCmd, "generate", "profile", "-o", out, u) + _, err = ExecuteCmd(rootCmd, "generate", "profile", "-o", fp, u) require.NoError(t, err) - r := loadResults(t, out) + r := loadResults(t, fp) require.Equal(t, "O", r.Operator.Name) require.Equal(t, opk, r.Operator.Key) @@ -248,7 +248,7 @@ func TestKey_ProfileBasics(t *testing.T) { // execute the command out := path.Join(ts.Dir, "out.json") - _, _, err = ExecuteCmd(createProfileCmd(), "-o", out, tc.u) + _, err = ExecuteCmd(createProfileCmd(), []string{"-o", out, tc.u}...) require.NoError(t, err) r := loadResults(t, out) @@ -314,7 +314,7 @@ func TestGenerateProfile_MultipleOperators(t *testing.T) { ts.AddUser(t, "A", "U") out := filepath.Join(ts.Dir, "profile.json") - _, _, err := ExecuteCmd(createProfileCmd(), "--output-file", out, "nsc://O/A/U") + _, err := ExecuteCmd(createProfileCmd(), []string{"--output-file", out, "nsc://O/A/U"}...) require.NoError(t, err) profile := loadNscEnvProfile(t, out) require.Contains(t, profile.UserCreds, filepath.FromSlash("/O/A/U.creds")) @@ -327,7 +327,7 @@ func TestGenerateProfile_NamesSeedsKeys(t *testing.T) { ts.AddUser(t, "A", "U") out := filepath.Join(ts.Dir, "profile.json") - _, _, err := ExecuteCmd(createProfileCmd(), "--output-file", out, "nsc://O/A/U?&names&seeds&keys") + _, err := ExecuteCmd(createProfileCmd(), []string{"--output-file", out, "nsc://O/A/U?&names&seeds&keys"}...) require.NoError(t, err) profile := loadNscEnvProfile(t, out) diff --git a/cmd/generateserverconfig.go b/cmd/generateserverconfig.go index 4a4801dd..2716fa5e 100644 --- a/cmd/generateserverconfig.go +++ b/cmd/generateserverconfig.go @@ -268,7 +268,12 @@ func (p *GenerateServerConfigParams) Run(ctx ActionCtx) (store.Status, error) { if err != nil { return nil, err } - if err := Write(p.outputFile, d); err != nil { + if IsStdOut(p.outputFile) { + _, err := fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), string(d)) + return nil, err + } + err = WriteFile(p.outputFile, d) + if err != nil { return nil, err } if !IsStdOut(p.outputFile) { diff --git a/cmd/importaccount_test.go b/cmd/importaccount_test.go index 16f49f37..da167056 100644 --- a/cmd/importaccount_test.go +++ b/cmd/importaccount_test.go @@ -16,13 +16,12 @@ package cmd import ( - "os" - "path/filepath" - "testing" - "github.com/nats-io/jwt/v2" "github.com/nats-io/nkeys" "github.com/stretchr/testify/require" + "os" + "path/filepath" + "testing" ) func Test_ImportAccountSelfSigned(t *testing.T) { @@ -47,12 +46,12 @@ func Test_ImportAccountSelfSigned(t *testing.T) { file := filepath.Join(ts.Dir, "account-selfsigned.jwt") err = os.WriteFile(file, []byte(theJWT), 0666) require.NoError(t, err) - _, _, err = ExecuteCmd(createImportAccountCmd(), "--file", file) + _, err = ExecuteCmd(createImportAccountCmd(), []string{"--file", file}...) require.NoError(t, err) check() - _, _, err = ExecuteCmd(createImportAccountCmd(), "--file", file) + _, err = ExecuteCmd(createImportAccountCmd(), []string{"--file", file}...) require.Error(t, err) - _, _, err = ExecuteCmd(createImportAccountCmd(), "--file", file, "--overwrite") + _, err = ExecuteCmd(createImportAccountCmd(), []string{"--file", file, "--overwrite"}...) require.NoError(t, err) check() } @@ -73,10 +72,10 @@ func Test_ImportAccountOtherOperator(t *testing.T) { err = os.WriteFile(file, []byte(theJWT), 0666) require.NoError(t, err) if force { - _, _, err = ExecuteCmd(createImportAccountCmd(), "--file", file, "--force") + _, err = ExecuteCmd(createImportAccountCmd(), []string{"--file", file, "--force"}...) require.NoError(t, err) } else { - _, _, err = ExecuteCmd(createImportAccountCmd(), "--file", file) + _, err = ExecuteCmd(createImportAccountCmd(), []string{"--file", file}...) require.Error(t, err) } } @@ -94,31 +93,31 @@ func Test_ImportDecoratedAccount(t *testing.T) { a, err := ts.Store.ReadRawAccountClaim("A") require.NoError(t, err) normal := filepath.Join(ts.Dir, "a.jwt") - err = Write(normal, a) + err = WriteFile(normal, a) require.NoError(t, err) // save a decorated jwt decorated := filepath.Join(ts.Dir, "decorated_a.jwt") - _, _, err = ExecuteCmd(rootCmd, "describe", "account", "A", "--raw", "--output-file", decorated) + _, err = ExecuteCmd(rootCmd, []string{"describe", "account", "A", "--raw", "--output-file", decorated}...) // delete the account require.NoError(t, err) - _, _, err = ExecuteCmd(createDeleteAccountCmd(), "A", "--force") + _, err = ExecuteCmd(createDeleteAccountCmd(), []string{"A", "--force"}...) require.NoError(t, err) _, err = ts.Store.ReadAccountClaim("A") require.Error(t, err) require.Equal(t, "account A does not exist in the current operator", err.Error()) // import the naked jwt - _, _, err = ExecuteCmd(rootCmd, "import", "account", "--file", normal) + _, err = ExecuteCmd(rootCmd, []string{"import", "account", "--file", normal}...) require.NoError(t, err) _, err = ts.Store.ReadAccountClaim("A") require.NoError(t, err) - _, _, err = ExecuteCmd(createDeleteAccountCmd(), "A", "--force") + _, err = ExecuteCmd(createDeleteAccountCmd(), []string{"A", "--force"}...) require.NoError(t, err) // import the decorated jwt - _, _, err = ExecuteCmd(rootCmd, "import", "account", "--file", decorated) + _, err = ExecuteCmd(rootCmd, []string{"import", "account", "--file", decorated}...) require.NoError(t, err) } @@ -132,22 +131,22 @@ func Test_ImportAccountFromDescribe(t *testing.T) { fp := filepath.Join(ts.Dir, "A.jwt") // generate a jwt with describe, and import it - _, _, err := ExecuteCmd(cmd, "--raw", "--output-file", fp) + _, err := ExecuteCmd(cmd, "--raw", "--output-file", fp) require.NoError(t, err) - _, _, err = ExecuteCmd(createDeleteAccountCmd(), "A") + _, err = ExecuteCmd(createDeleteAccountCmd(), "A") require.NoError(t, err) - _, _, err = ExecuteCmd(createImportAccountCmd(), "--file", fp) + _, err = ExecuteCmd(createImportAccountCmd(), "--file", fp) require.NoError(t, err) require.NoError(t, os.Remove(fp)) // generate a jwt with describe that is not armored, and import it cmd = createDescribeAccountCmd() cmd.Flags().BoolVarP(&Raw, "raw", "R", false, "output the raw JWT (exclusive of long-ids)") - stdout, _, err := ExecuteCmd(cmd, "--raw") + stdout, err := ExecuteCmd(cmd, "--raw") require.NoError(t, err) - require.NoError(t, Write(fp, []byte(stdout))) - _, _, err = ExecuteCmd(createDeleteAccountCmd(), "A") + require.NoError(t, WriteFile(fp, []byte(stdout.Out))) + _, err = ExecuteCmd(createDeleteAccountCmd(), "A") require.NoError(t, err) - _, _, err = ExecuteCmd(createImportAccountCmd(), "--file", fp) + _, err = ExecuteCmd(createImportAccountCmd(), "--file", fp) require.NoError(t, err) } diff --git a/cmd/importkeys_test.go b/cmd/importkeys_test.go index da804b25..022380d8 100644 --- a/cmd/importkeys_test.go +++ b/cmd/importkeys_test.go @@ -17,23 +17,22 @@ package cmd import ( "fmt" - "path/filepath" - "testing" - "github.com/nats-io/nkeys" "github.com/stretchr/testify/require" + "path/filepath" + "testing" ) func storeKeys(t *testing.T, dir string) []nkeys.KeyPair { require.NoError(t, MaybeMakeDir(dir)) os, opk, okp := CreateOperatorKey(t) - err := Write(filepath.Join(dir, fmt.Sprintf("%s.nk", opk)), os) + err := WriteFile(filepath.Join(dir, fmt.Sprintf("%s.nk", opk)), os) require.NoError(t, err) as, apk, akp := CreateAccountKey(t) - err = Write(filepath.Join(dir, fmt.Sprintf("%s.nk", apk)), as) + err = WriteFile(filepath.Join(dir, fmt.Sprintf("%s.nk", apk)), as) require.NoError(t, err) us, upk, ukp := CreateUserKey(t) - err = Write(filepath.Join(dir, fmt.Sprintf("%s.nk", upk)), us) + err = WriteFile(filepath.Join(dir, fmt.Sprintf("%s.nk", upk)), us) require.NoError(t, err) return []nkeys.KeyPair{okp, akp, ukp} @@ -47,7 +46,7 @@ func Test_ImportKeys(t *testing.T) { keys := storeKeys(t, dir) require.True(t, len(keys) > 0) - _, _, err := ExecuteCmd(createImportKeysCmd(), "--dir", dir) + _, err := ExecuteCmd(createImportKeysCmd(), []string{"--dir", dir}...) require.NoError(t, err) for _, kp := range keys { pk, err := kp.PublicKey() @@ -69,7 +68,7 @@ func Test_ImportKeysNotRecursive(t *testing.T) { keys2 := storeKeys(t, dir2) require.True(t, len(keys2) > 0) - _, _, err := ExecuteCmd(createImportKeysCmd(), "--dir", dir) + _, err := ExecuteCmd(createImportKeysCmd(), []string{"--dir", dir}...) require.NoError(t, err) for _, kp := range keys { pk, err := kp.PublicKey() @@ -98,7 +97,7 @@ func Test_ImportKeyRecursive(t *testing.T) { keys2 := storeKeys(t, dir2) require.True(t, len(keys2) > 0) - _, _, err := ExecuteCmd(createImportKeysCmd(), "--dir", dir, "--recurse") + _, err := ExecuteCmd(createImportKeysCmd(), []string{"--dir", dir, "--recurse"}...) require.NoError(t, err) keys = append(keys, keys2...) for _, kp := range keys { diff --git a/cmd/importuser_test.go b/cmd/importuser_test.go index f2f60643..f7bd9727 100644 --- a/cmd/importuser_test.go +++ b/cmd/importuser_test.go @@ -16,20 +16,19 @@ package cmd import ( - "os" - "path/filepath" - "testing" - "github.com/nats-io/jwt/v2" "github.com/nats-io/nkeys" "github.com/stretchr/testify/require" + "os" + "path/filepath" + "testing" ) func Test_ImportUserCreds(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "acc") + _, err := ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "acc"}...) require.NoError(t, err) aClaim, _ := ts.Store.ReadAccountClaim("acc") aKp, err := ts.KeyStore.GetKeyPair(aClaim.Subject) @@ -58,12 +57,12 @@ func Test_ImportUserCreds(t *testing.T) { file := filepath.Join(ts.Dir, "user.creds") err = os.WriteFile(file, creds, 0666) require.NoError(t, err) - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", file) + _, err = ExecuteCmd(createImportUserCmd(), []string{"--file", file}...) require.NoError(t, err) check() - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", file) + _, err = ExecuteCmd(createImportUserCmd(), []string{"--file", file}...) require.Error(t, err) - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", file, "--overwrite") + _, err = ExecuteCmd(createImportUserCmd(), []string{"--file", file, "--overwrite"}...) require.NoError(t, err) check() } @@ -71,7 +70,7 @@ func Test_ImportUserCreds(t *testing.T) { func Test_ImportUserJWT(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", "acc") + _, err := ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "acc"}...) require.NoError(t, err) aClaim, _ := ts.Store.ReadAccountClaim("acc") @@ -94,12 +93,12 @@ func Test_ImportUserJWT(t *testing.T) { file := filepath.Join(ts.Dir, "user.jwt") err = os.WriteFile(file, []byte(theJWT), 0666) require.NoError(t, err) - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", file) + _, err = ExecuteCmd(createImportUserCmd(), []string{"--file", file}...) require.NoError(t, err) check() - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", file) + _, err = ExecuteCmd(createImportUserCmd(), []string{"--file", file}...) require.Error(t, err) - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", file, "--overwrite") + _, err = ExecuteCmd(createImportUserCmd(), []string{"--file", file, "--overwrite"}...) require.NoError(t, err) check() } @@ -117,7 +116,7 @@ func Test_ImportUserOtherAccount(t *testing.T) { file := filepath.Join(ts.Dir, "user.jwt") err = os.WriteFile(file, []byte(theJWT), 0666) require.NoError(t, err) - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", file) + _, err = ExecuteCmd(createImportUserCmd(), []string{"--file", file}...) require.Error(t, err) } @@ -128,35 +127,35 @@ func Test_ImportUserFromDescribe(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") creds := filepath.Join(ts.Dir, "u.creds") - _, _, err := ExecuteCmd(createGenerateCredsCmd(), "--output-file", creds) + _, err := ExecuteCmd(createGenerateCredsCmd(), "--output-file", creds) require.NoError(t, err) - _, _, err = ExecuteCmd(createDeleteUserCmd(), "U") + _, err = ExecuteCmd(createDeleteUserCmd(), "U") require.NoError(t, err) // import a creds - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", creds) + _, err = ExecuteCmd(createImportUserCmd(), "--file", creds) require.NoError(t, err) // generate a jwt with describe, and import it cmd := createDescribeUserCmd() cmd.Flags().BoolVarP(&Raw, "raw", "R", false, "output the raw JWT (exclusive of long-ids)") fp := filepath.Join(ts.Dir, "u.jwt") - _, _, err = ExecuteCmd(cmd, "--raw", "--output-file", fp) + _, err = ExecuteCmd(cmd, "--raw", "--output-file", fp) require.NoError(t, err) - _, _, err = ExecuteCmd(createDeleteUserCmd(), "U") + _, err = ExecuteCmd(createDeleteUserCmd(), "U") require.NoError(t, err) - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", fp) + _, err = ExecuteCmd(createImportUserCmd(), "--file", fp) require.NoError(t, err) require.NoError(t, os.Remove(fp)) // generate a jwt with describe that is not armored, and import it cmd = createDescribeUserCmd() cmd.Flags().BoolVarP(&Raw, "raw", "R", false, "output the raw JWT (exclusive of long-ids)") - stdout, _, err := ExecuteCmd(cmd, "--raw") + out, err := ExecuteCmd(cmd, "--raw") require.NoError(t, err) - require.NoError(t, Write(fp, []byte(stdout))) - _, _, err = ExecuteCmd(createDeleteUserCmd(), "U") + require.NoError(t, WriteFile(fp, []byte(out.Out))) + _, err = ExecuteCmd(createDeleteUserCmd(), "U") require.NoError(t, err) - _, _, err = ExecuteCmd(createImportUserCmd(), "--file", fp) + _, err = ExecuteCmd(createImportUserCmd(), "--file", fp) require.NoError(t, err) } diff --git a/cmd/init_test.go b/cmd/init_test.go index 51882724..f96dde39 100644 --- a/cmd/init_test.go +++ b/cmd/init_test.go @@ -16,18 +16,17 @@ package cmd import ( - "net/url" - "testing" - cli "github.com/nats-io/cliprompts/v2" "github.com/stretchr/testify/require" + "net/url" + "testing" ) func Test_InitLocal(t *testing.T) { ts := NewTestStore(t, "X") defer ts.Done(t) - _, _, err := ExecuteCmd(createInitCmd(), "--name", "O") + _, err := ExecuteCmd(createInitCmd(), []string{"--name", "O"}...) require.NoError(t, err) ts.VerifyOperator(t, "O", false) @@ -41,7 +40,7 @@ func Test_InitExists(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(createInitCmd(), "--name", "O") + _, err := ExecuteCmd(createInitCmd(), []string{"--name", "O"}...) require.Error(t, err) } @@ -56,7 +55,7 @@ func Test_InitDeploy(t *testing.T) { require.NoError(t, err) ourl.Path = "/jwt/v1/operator" - _, _, err = ExecuteCmd(createInitCmd(), "--name", "O", "--url", ourl.String()) + _, err = ExecuteCmd(createInitCmd(), []string{"--name", "O", "--url", ourl.String()}...) require.NoError(t, err) ts.VerifyOperator(t, "T", true) @@ -75,7 +74,7 @@ func Test_InitRandomName(t *testing.T) { require.NoError(t, err) ourl.Path = "/jwt/v1/operator" - _, _, err = ExecuteCmd(createInitCmd(), "--url", ourl.String()) + _, err = ExecuteCmd(createInitCmd(), []string{"--url", ourl.String()}...) require.NoError(t, err) name := GetLastRandomName() @@ -96,7 +95,7 @@ func Test_InitStarName(t *testing.T) { require.NoError(t, err) ourl.Path = "/jwt/v1/operator" - _, _, err = ExecuteCmd(createInitCmd(), "--url", ourl.String(), "-n", "*") + _, err = ExecuteCmd(createInitCmd(), []string{"--url", ourl.String(), "-n", "*"}...) require.NoError(t, err) name := GetLastRandomName() @@ -131,7 +130,7 @@ func Test_InitWellKnown(t *testing.T) { wkops = append(wkops, ops...) wellKnownOperators = wkops - _, _, err = ExecuteCmd(createInitCmd(), "--remote-operator", "T", "--name", "A") + _, err = ExecuteCmd(createInitCmd(), []string{"--remote-operator", "T", "--name", "A"}...) require.NoError(t, err) ts.VerifyOperator(t, "T", true) @@ -164,11 +163,11 @@ func Test_InitWellKnown2(t *testing.T) { wellKnownOperators = wkops // get the managed operator on the first - _, _, err = ExecuteCmd(createInitCmd(), "--remote-operator", "T", "--name", "A") + _, err = ExecuteCmd(createInitCmd(), []string{"--remote-operator", "T", "--name", "A"}...) require.NoError(t, err) // now add another account - _, _, err = ExecuteCmd(createInitCmd(), "--remote-operator", "T", "--name", "B") + _, err = ExecuteCmd(createInitCmd(), []string{"--remote-operator", "T", "--name", "B"}...) require.NoError(t, err) ts.VerifyOperator(t, "T", true) @@ -202,7 +201,7 @@ func Test_InitWellKnownV1Operator(t *testing.T) { wkops = append(wkops, ops...) wellKnownOperators = wkops - _, _, err = ExecuteCmd(createInitCmd(), "--remote-operator", "T", "--name", "A") + _, err = ExecuteCmd(createInitCmd(), []string{"--remote-operator", "T", "--name", "A"}...) require.Error(t, err) require.Contains(t, err.Error(), "the operator jwt (v1) is incompatible this version of nsc") } @@ -231,7 +230,7 @@ func Test_InitWellKnownInteractive(t *testing.T) { wkops = append(wkops, ops...) wellKnownOperators = wkops - _, _, err = ExecuteInteractiveCmd(createInitCmd(), []interface{}{ts.GetStoresRoot(), 0, "A"}) + _, err = ExecuteInteractiveCmd(createInitCmd(), []interface{}{ts.GetStoresRoot(), 0, "A"}) require.NoError(t, err) ts.VerifyOperator(t, "T", true) @@ -244,7 +243,7 @@ func Test_InitLocalInteractive(t *testing.T) { defer ts.Done(t) cli.LogFn = t.Log - _, _, err := ExecuteInteractiveCmd(createInitCmd(), []interface{}{ts.GetStoresRoot(), 1, "O"}) + _, err := ExecuteInteractiveCmd(createInitCmd(), []interface{}{ts.GetStoresRoot(), 1, "O"}) require.NoError(t, err) ts.VerifyOperator(t, "O", false) @@ -267,7 +266,7 @@ func Test_InitCustomInteractive(t *testing.T) { require.NoError(t, err) ourl.Path = "/jwt/v1/operator" - _, _, err = ExecuteInteractiveCmd(createInitCmd(), []interface{}{ts.GetStoresRoot(), 2, ourl.String(), "A"}) + _, err = ExecuteInteractiveCmd(createInitCmd(), []interface{}{ts.GetStoresRoot(), 2, ourl.String(), "A"}) require.NoError(t, err) ts.VerifyOperator(t, "T", true) @@ -288,7 +287,7 @@ func Test_InitDuplicate(t *testing.T) { u := ourl.String() // get the managed operator on the first - _, _, err = ExecuteCmd(createInitCmd(), "--url", u, "--name", "A") + _, err = ExecuteCmd(createInitCmd(), []string{"--url", u, "--name", "A"}...) require.NoError(t, err) ts.VerifyOperator(t, "T", true) @@ -296,7 +295,7 @@ func Test_InitDuplicate(t *testing.T) { ts.VerifyUser(t, "T", "A", "A", true) // try to do it again with the same name - _, _, err = ExecuteCmd(createInitCmd(), "--url", u, "--name", "A") + _, err = ExecuteCmd(createInitCmd(), []string{"--url", u, "--name", "A"}...) require.Error(t, err) require.Contains(t, err.Error(), "an account named \"A\" already exists") } diff --git a/cmd/keys_test.go b/cmd/keys_test.go index 7d129e8b..746d75ce 100644 --- a/cmd/keys_test.go +++ b/cmd/keys_test.go @@ -17,18 +17,16 @@ package cmd import ( "fmt" + "github.com/nats-io/nkeys" + "github.com/nats-io/nsc/v2/cmd/store" + "github.com/stretchr/testify/require" "os" "path/filepath" "runtime" "testing" - - "github.com/nats-io/nkeys" - "github.com/stretchr/testify/require" - - "github.com/nats-io/nsc/v2/cmd/store" ) -func storeOldCreds(ts *TestStore, operator string, account string, user string, data []byte) error { +func storeOldCreds(ts *TestStore, operator string, account string, user string, _data []byte) error { ks := filepath.Join(ts.Dir, "keys") target := filepath.Join(ks, operator, "accounts", account, "users", fmt.Sprintf("%s.creds", user)) return os.WriteFile(target, []byte(user), 0700) @@ -106,9 +104,9 @@ func Test_NoMigration(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, stdErr, err := ExecuteCmd(createMigrateKeysCmd()) + out, err := ExecuteCmd(createMigrateKeysCmd()) require.NoError(t, err) - require.Contains(t, stdErr, "does not need migration") + require.Contains(t, out.Out, "does not need migration") } func Test_MigrateKeys(t *testing.T) { @@ -138,7 +136,7 @@ func Test_MigrateKeys(t *testing.T) { require.NoError(t, err) require.True(t, needsUpdate) - _, _, err = ExecuteCmd(createMigrateKeysCmd()) + _, err = ExecuteCmd(createMigrateKeysCmd(), []string{}...) require.NoError(t, err) // directory for keystore has a "keys" and "creds" diff --git a/cmd/list_test.go b/cmd/list_test.go index 1db0e2a9..10f2cb62 100644 --- a/cmd/list_test.go +++ b/cmd/list_test.go @@ -21,11 +21,11 @@ func Test_ListOperatorsJSON(t *testing.T) { cmd := createListOperatorsCmd() cmd.PersistentFlags().BoolVarP(&Json, "json", "J", false, "describe as JSON") - _, stderr, err := ExecuteCmd(cmd, "--json") + out, err := ExecuteCmd(cmd, "--json") require.NoError(t, err) var entries []entryJSON - require.NoError(t, json.Unmarshal([]byte(stderr), &entries)) + require.NoError(t, json.Unmarshal([]byte(out.Out), &entries)) assert.Len(t, entries, 2) assert.Equal(t, entries[0].Name, "O") assert.NotEmpty(t, entries[0].PublicKey) @@ -43,11 +43,11 @@ func Test_ListAccountsJSON(t *testing.T) { cmd := createListAccountsCmd() cmd.PersistentFlags().BoolVarP(&Json, "json", "J", false, "describe as JSON") - _, stderr, err := ExecuteCmd(cmd, "--json") + out, err := ExecuteCmd(cmd, "--json") require.NoError(t, err) var entries []entryJSON - require.NoError(t, json.Unmarshal([]byte(stderr), &entries)) + require.NoError(t, json.Unmarshal([]byte(out.Out), &entries)) assert.Len(t, entries, 2) assert.Equal(t, entries[0].Name, "A") assert.Equal(t, entries[0].PublicKey, ts.GetAccountPublicKey(t, "A")) @@ -66,11 +66,11 @@ func Test_ListUsersJSON(t *testing.T) { cmd := createListUsersCmd() cmd.PersistentFlags().BoolVarP(&Json, "json", "J", false, "describe as JSON") - _, stderr, err := ExecuteCmd(cmd, "--json") + out, err := ExecuteCmd(cmd, "--json") require.NoError(t, err) var entries []entryJSON - require.NoError(t, json.Unmarshal([]byte(stderr), &entries)) + require.NoError(t, json.Unmarshal([]byte(out.Out), &entries)) assert.Len(t, entries, 2) assert.Equal(t, entries[0].Name, "U") assert.Equal(t, entries[0].PublicKey, ts.GetUserPublicKey(t, "A", "U")) diff --git a/cmd/listeditor_test.go b/cmd/listeditor_test.go index bdcf87f6..0d19f452 100644 --- a/cmd/listeditor_test.go +++ b/cmd/listeditor_test.go @@ -45,7 +45,7 @@ func TestListEditorParams(t *testing.T) { return nil } cmd := listEditorCmd(&p) - _, _, err := ExecuteCmd(cmd, "--test", "a", "--test", "b") + _, err := ExecuteCmd(cmd, []string{"--test", "a", "--test", "b"}...) require.NoError(t, err) require.True(t, validatorCalled) require.Len(t, p.Values, 2) @@ -61,7 +61,7 @@ func TestListEditorParams_Interactive(t *testing.T) { return nil } cmd := listEditorCmd(&p) - _, _, err := ExecuteInteractiveCmd(cmd, []interface{}{true, "x", true, "y", false}) + _, err := ExecuteInteractiveCmd(cmd, []interface{}{true, "x", true, "y", false}) require.NoError(t, err) require.True(t, validatorCalled) require.Len(t, p.Values, 2) @@ -77,7 +77,7 @@ func TestListEditorParams_InteractiveEdit(t *testing.T) { return nil } cmd := listEditorCmd(p) - _, _, err := ExecuteInteractiveCmd(cmd, []interface{}{"aa", "bb", true, "x", true, "y", false}, "--test", "a", "--test", "b") + _, err := ExecuteInteractiveCmd(cmd, []interface{}{"aa", "bb", true, "x", true, "y", false}, "--test", "a", "--test", "b") require.NoError(t, err) require.True(t, validatorCalled) require.Len(t, p.Values, 4) diff --git a/cmd/listkeys_test.go b/cmd/listkeys_test.go index f661ac53..4b5db4af 100644 --- a/cmd/listkeys_test.go +++ b/cmd/listkeys_test.go @@ -31,9 +31,9 @@ func Test_ListKeysDefault(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, stderr, err := ExecuteCmd(createListKeysCmd()) + out, err := ExecuteCmd(createListKeysCmd()) require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr := StripTableDecorations(out.Out) require.Contains(t, stderr, fmt.Sprintf("%s %s *", "O", ts.GetOperatorPublicKey(t))) require.Contains(t, stderr, fmt.Sprintf("%s %s *", "A", ts.GetAccountPublicKey(t, "A"))) @@ -47,9 +47,9 @@ func Test_listKeysOperatorOnly(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, stderr, err := ExecuteCmd(createListKeysCmd(), "--operator") + out, err := ExecuteCmd(createListKeysCmd(), "--operator") require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr := StripTableDecorations(out.Out) require.Contains(t, stderr, fmt.Sprintf("%s %s *", "O", ts.GetOperatorPublicKey(t))) require.NotContains(t, stderr, fmt.Sprintf("%s %s *", "A", ts.GetAccountPublicKey(t, "A"))) @@ -63,9 +63,9 @@ func Test_listKeysAccountOnly(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, stderr, err := ExecuteCmd(createListKeysCmd(), "--accounts") + out, err := ExecuteCmd(createListKeysCmd(), "--accounts") require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr := StripTableDecorations(out.Out) require.NotContains(t, stderr, fmt.Sprintf("%s %s *", "O", ts.GetOperatorPublicKey(t))) require.Contains(t, stderr, fmt.Sprintf("%s %s *", "A", ts.GetAccountPublicKey(t, "A"))) @@ -79,9 +79,9 @@ func Test_ListKeysUserOnly(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, stderr, err := ExecuteCmd(createListKeysCmd(), "--users") + out, err := ExecuteCmd(createListKeysCmd(), "--users") require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr := StripTableDecorations(out.Out) require.NotContains(t, stderr, fmt.Sprintf("%s %s *", "O", ts.GetOperatorPublicKey(t))) require.NotContains(t, stderr, fmt.Sprintf("%s %s *", "A", ts.GetAccountPublicKey(t, "A"))) @@ -99,9 +99,9 @@ func Test_ListKeysOther(t *testing.T) { _, err := ts.KeyStore.Store(kp) require.NoError(t, err) - _, stderr, err := ExecuteCmd(createListKeysCmd(), "--all", "--not-referenced") + out, err := ExecuteCmd(createListKeysCmd(), "--all", "--not-referenced") require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr := StripTableDecorations(out.Out) require.NotContains(t, stderr, fmt.Sprintf("%s %s *", "O", ts.GetOperatorPublicKey(t))) require.NotContains(t, stderr, fmt.Sprintf("%s %s *", "A", ts.GetAccountPublicKey(t, "A"))) @@ -118,9 +118,9 @@ func Test_ListKeysFilter(t *testing.T) { opk := ts.GetOperatorPublicKey(t) - _, stderr, err := ExecuteCmd(createListKeysCmd(), "--all", "--filter", opk[:10]) + out, err := ExecuteCmd(createListKeysCmd(), "--all", "--filter", opk[:10]) require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr := StripTableDecorations(out.Out) require.Contains(t, stderr, fmt.Sprintf("%s %s *", "O", opk)) require.NotContains(t, stderr, fmt.Sprintf("%s %s *", "A", ts.GetAccountPublicKey(t, "A"))) @@ -132,9 +132,8 @@ func Test_ListKeysNoKeyStore(t *testing.T) { defer ts.Done(t) old := store.KeyStorePath store.KeyStorePath = ts.KeysDir - _, _, err := ExecuteCmd(createListKeysCmd()) + _, err := ExecuteCmd(createListKeysCmd()) require.Error(t, err) - t.Log(err.Error()) require.Equal(t, err.Error(), fmt.Sprintf("keystore `%s` does not exist", ts.KeysDir)) store.KeyStorePath = old } @@ -145,7 +144,7 @@ func Test_listKeysAuthorizationXKey(t *testing.T) { ts.AddAccount(t, "A") _, uPK, _ := CreateUserKey(t) - _, _, err := ExecuteCmd(createEditAuthorizationCallout(), "--auth-user", uPK, "--curve", "generate") + _, err := ExecuteCmd(createEditAuthorizationCallout(), "--auth-user", uPK, "--curve", "generate") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -154,21 +153,21 @@ func Test_listKeysAuthorizationXKey(t *testing.T) { xPK := ac.Authorization.XKey require.NotEmpty(t, xPK) - _, stderr, err := ExecuteCmd(createListKeysCmd(), "-A") + out, err := ExecuteCmd(createListKeysCmd(), "-A") require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr := StripTableDecorations(out.Out) require.Contains(t, stderr, xPK) - _, _, err = ExecuteCmd(createEditAuthorizationCallout(), "--rm-curve") + _, err = ExecuteCmd(createEditAuthorizationCallout(), "--rm-curve") require.NoError(t, err) - _, stderr, err = ExecuteCmd(createListKeysCmd(), "-A") + out, err = ExecuteCmd(createListKeysCmd(), "-A") require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr = StripTableDecorations(out.Out) require.NotContains(t, stderr, xPK) - _, stderr, err = ExecuteCmd(createListKeysCmd(), "--not-referenced") + out, err = ExecuteCmd(createListKeysCmd(), "--not-referenced") require.NoError(t, err) - stderr = StripTableDecorations(stderr) + stderr = StripTableDecorations(out.Out) require.Contains(t, stderr, xPK) } diff --git a/cmd/memresolverconfigbuilder_test.go b/cmd/memresolverconfigbuilder_test.go index 7a8b91fb..d9995987 100644 --- a/cmd/memresolverconfigbuilder_test.go +++ b/cmd/memresolverconfigbuilder_test.go @@ -22,9 +22,8 @@ import ( "testing" "github.com/nats-io/nats-server/v2/server" - "github.com/stretchr/testify/require" - "github.com/nats-io/nsc/v2/cmd/store" + "github.com/stretchr/testify/require" ) func Test_MemResolverContainsStandardProperties(t *testing.T) { @@ -150,8 +149,8 @@ func Test_MemResolverDir(t *testing.T) { ts.AddAccount(t, "B") out := filepath.Join(ts.Dir, "conf") - _, _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", - "--dir", out) + _, err := ExecuteCmd(createServerConfigCmd(), []string{"--mem-resolver", + "--dir", out}...) require.NoError(t, err) require.FileExists(t, filepath.Join(out, "O.jwt")) require.FileExists(t, filepath.Join(out, "A.jwt")) @@ -180,8 +179,8 @@ func Test_MemResolverServerParse(t *testing.T) { serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", - "--config-file", serverconf) + _, err := ExecuteCmd(createServerConfigCmd(), []string{"--mem-resolver", + "--config-file", serverconf}...) require.NoError(t, err) @@ -195,11 +194,11 @@ func Test_MemResolverContainsSysAccount(t *testing.T) { ts.AddAccount(t, "A") ts.AddAccount(t, "B") - stdout, _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", + out, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", "--sys-account", "B") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") require.NoError(t, err) - require.Contains(t, stdout, fmt.Sprintf("system_account: %s", ac.Subject)) + require.Contains(t, out.Out, fmt.Sprintf("system_account: %s", ac.Subject)) } diff --git a/cmd/migrate_test.go b/cmd/migrate_test.go index 49f3aa4b..cbdc74b6 100644 --- a/cmd/migrate_test.go +++ b/cmd/migrate_test.go @@ -34,7 +34,7 @@ func Test_Migrate(t *testing.T) { ts.AddUser(t, "B", "b") ts.AddOperator(t, "OO") - _, _, err := ExecuteCmd(createMigrateCmd(), "--url", filepath.Join(ts.GetStoresRoot(), "O", "accounts", "A", "A.jwt")) + _, err := ExecuteCmd(createMigrateCmd(), []string{"--url", filepath.Join(ts.GetStoresRoot(), "O", "accounts", "A", "A.jwt")}...) require.NoError(t, err) oos, err := store.LoadStore(filepath.Join(ts.GetStoresRoot(), "OO")) @@ -55,7 +55,7 @@ func Test_MigrateMany(t *testing.T) { ts.AddUser(t, "B", "b") ts.AddOperator(t, "OO") - _, _, err := ExecuteCmd(createMigrateCmd(), "--operator-dir", filepath.Join(ts.GetStoresRoot(), "O")) + _, err := ExecuteCmd(createMigrateCmd(), []string{"--operator-dir", filepath.Join(ts.GetStoresRoot(), "O")}...) require.NoError(t, err) oos, err := store.LoadStore(filepath.Join(ts.GetStoresRoot(), "OO")) @@ -81,7 +81,7 @@ func Test_MigrateSingleInteractive(t *testing.T) { ts.AddOperator(t, "OO") args := []interface{}{false, filepath.Join(ts.GetStoresRoot(), "O", store.Accounts, "A", "A.jwt")} - _, _, err := ExecuteInteractiveCmd(createMigrateCmd(), args) + _, err := ExecuteInteractiveCmd(createMigrateCmd(), args) require.NoError(t, err) oos, err := store.LoadStore(filepath.Join(ts.GetStoresRoot(), "OO")) @@ -111,7 +111,7 @@ func Test_MigrateManaged(t *testing.T) { ts.SwitchOperator(t, "T") // migrate the local operator - _, _, err := ExecuteCmd(createMigrateCmd(), "--operator-dir", filepath.Join(ts.StoreDir, "O")) + _, err := ExecuteCmd(createMigrateCmd(), []string{"--operator-dir", filepath.Join(ts.StoreDir, "O")}...) require.NoError(t, err) require.NotNil(t, m[apk]) diff --git a/cmd/natsresolverconfigbuilder_test.go b/cmd/natsresolverconfigbuilder_test.go index ac338115..1b2f815a 100644 --- a/cmd/natsresolverconfigbuilder_test.go +++ b/cmd/natsresolverconfigbuilder_test.go @@ -18,21 +18,20 @@ package cmd import ( "bytes" "fmt" + "github.com/nats-io/nats-server/v2/server" + "github.com/stretchr/testify/require" "os" "path/filepath" "testing" - - "github.com/nats-io/nats-server/v2/server" - "github.com/stretchr/testify/require" ) func Test_NatsResolverServerParse(t *testing.T) { ts := NewEmptyStore(t) defer ts.Done(t) - _, _, err := ExecuteCmd(createAddOperatorCmd(), "--name", "OP", "--sys") + _, err := ExecuteCmd(createAddOperatorCmd(), []string{"--name", "OP", "--sys"}...) require.NoError(t, err) serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--nats-resolver", "--config-file", serverconf) + _, err = ExecuteCmd(createServerConfigCmd(), []string{"--nats-resolver", "--config-file", serverconf}...) require.NoError(t, err) // modify the generated file so the jwt directory does not get created where the test is running data, err := os.ReadFile(serverconf) diff --git a/cmd/numberparams_test.go b/cmd/numberparams_test.go index 73918f8f..80e0e56d 100644 --- a/cmd/numberparams_test.go +++ b/cmd/numberparams_test.go @@ -47,7 +47,7 @@ func numberEditorCmd(params *NumberParams) *cobra.Command { func TestNumberParams_BindFlags(t *testing.T) { var p NumberParams cmd := numberEditorCmd(&p) - _, _, err := ExecuteCmd(cmd, "--number", "10") + _, err := ExecuteCmd(cmd, []string{"--number", "10"}...) require.NoError(t, err) require.Equal(t, NumberParams(10), p) @@ -56,7 +56,7 @@ func TestNumberParams_BindFlags(t *testing.T) { func TestNumberParams_Edit(t *testing.T) { var p NumberParams cmd := numberEditorCmd(&p) - _, _, err := ExecuteInteractiveCmd(cmd, []interface{}{"404"}) + _, err := ExecuteInteractiveCmd(cmd, []interface{}{"404"}) require.NoError(t, err) require.Equal(t, NumberParams(404), p) diff --git a/cmd/options_test.go b/cmd/options_test.go index 204b427e..c1c76500 100644 --- a/cmd/options_test.go +++ b/cmd/options_test.go @@ -16,11 +16,10 @@ package cmd import ( + "github.com/stretchr/testify/require" "os" "path/filepath" "testing" - - "github.com/stretchr/testify/require" ) func TestNoGitIgnore(t *testing.T) { @@ -43,12 +42,11 @@ func TestCwdOnly(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, stderr, err := ExecuteCmd(GetRootCmd(), "env") + out, err := ExecuteCmd(GetRootCmd(), "env") require.NoError(t, err) - stderr = StripTableDecorations(stderr) - require.Contains(t, stderr, "$NSC_CWD_ONLY Yes") + require.Contains(t, StripTableDecorations(out.Out), "$NSC_CWD_ONLY Yes") - _, _, err = ExecuteCmd(createEnvCmd(), "--account", "A") + _, err = ExecuteCmd(createEnvCmd(), []string{"--account", "A"}...) require.Error(t, err) require.Contains(t, err.Error(), "$NSC_CWD_ONLY is set") } diff --git a/cmd/pull_test.go b/cmd/pull_test.go index 0877eea0..789e6c61 100644 --- a/cmd/pull_test.go +++ b/cmd/pull_test.go @@ -18,14 +18,13 @@ package cmd import ( "bytes" "fmt" + "github.com/nats-io/jwt/v2" + "github.com/nats-io/nkeys" + "github.com/stretchr/testify/require" "os" "path/filepath" "testing" "time" - - "github.com/nats-io/jwt/v2" - "github.com/nats-io/nkeys" - "github.com/stretchr/testify/require" ) func editAccount(t *testing.T, kp nkeys.KeyPair, d []byte, tag string) []byte { @@ -53,7 +52,7 @@ func Test_SyncAccount(t *testing.T) { d := editAccount(t, kp, m[pk], "test") m[pk] = d - _, _, err = ExecuteCmd(createPullCmd()) + _, err = ExecuteCmd(createPullCmd(), []string{}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -82,7 +81,7 @@ func Test_SyncMultipleAccount(t *testing.T) { d = editAccount(t, kp, m[pk], "test") m[pk] = d - _, _, err = ExecuteCmd(createPullCmd(), "--all") + _, err = ExecuteCmd(createPullCmd(), []string{"--all"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -98,7 +97,7 @@ func Test_SyncNoAccountServer(t *testing.T) { ts := NewTestStore(t, "O") ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createPullCmd()) + _, err := ExecuteCmd(createPullCmd(), []string{}...) require.Error(t, err) } @@ -123,7 +122,7 @@ func Test_SyncNewer(t *testing.T) { require.NoError(t, err) require.Contains(t, ac.Tags, "test") - _, _, err = ExecuteCmd(createPullCmd()) + _, err = ExecuteCmd(createPullCmd(), []string{}...) require.Error(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -131,7 +130,7 @@ func Test_SyncNewer(t *testing.T) { require.Contains(t, ac.Tags, "test") // now allow the overwrite - _, _, err = ExecuteCmd(createPullCmd(), "--overwrite-newer") + _, err = ExecuteCmd(createPullCmd(), []string{"--overwrite-newer"}...) if err != nil { panic(err) } @@ -144,13 +143,13 @@ func Test_SyncNewer(t *testing.T) { func Test_SyncNewerFromNatsResolver(t *testing.T) { ts := NewEmptyStore(t) defer ts.Done(t) - _, _, err := ExecuteCmd(createAddOperatorCmd(), "--name", "OP", "--sys") + _, err := ExecuteCmd(createAddOperatorCmd(), []string{"--name", "OP", "--sys"}...) require.NoError(t, err) ts.SwitchOperator(t, "OP") // switch the operator so ts is in a usable state to obtain operator key serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--nats-resolver", "--config-file", serverconf) + _, err = ExecuteCmd(createServerConfigCmd(), []string{"--nats-resolver", "--config-file", serverconf}...) require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "AC1") + _, err = ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "AC1"}...) require.NoError(t, err) // modify the generated file so testing becomes easier by knowing where the jwt directory is data, err := os.ReadFile(serverconf) @@ -177,12 +176,12 @@ func Test_SyncNewerFromNatsResolver(t *testing.T) { ports := ts.RunServerWithConfig(t, serverconf) require.NotNil(t, ports) // only after server start as ports are not yet known in tests - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", ports.Nats[0]) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--account-jwt-server-url", ports.Nats[0]}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createPullCmd(), "--all") + _, err = ExecuteCmd(createPullCmd(), []string{"--all"}...) require.NoError(t, err) // again, this time with system account and user specified - _, _, err = ExecuteCmd(createPullCmd(), "--all", "--system-account", "SYS", "--system-user", "sys") + _, err = ExecuteCmd(createPullCmd(), []string{"--all", "--system-account", "SYS", "--system-user", "sys"}...) require.NoError(t, err) // claim now exists in nsc store claim2, err := ts.Store.ReadAccountClaim("acc-name") @@ -194,13 +193,13 @@ func Test_SyncNewerFromNatsResolver(t *testing.T) { func Test_SyncNewerFromNatsResolverWs(t *testing.T) { ts := NewEmptyStore(t) defer ts.Done(t) - _, _, err := ExecuteCmd(createAddOperatorCmd(), "--name", "OP", "--sys") + _, err := ExecuteCmd(createAddOperatorCmd(), []string{"--name", "OP", "--sys"}...) require.NoError(t, err) ts.SwitchOperator(t, "OP") // switch the operator so ts is in a usable state to obtain operator key serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--nats-resolver", "--config-file", serverconf) + _, err = ExecuteCmd(createServerConfigCmd(), []string{"--nats-resolver", "--config-file", serverconf}...) require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "AC1") + _, err = ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "AC1"}...) require.NoError(t, err) // modify the generated file so testing becomes easier by knowing where the jwt directory is data, err := os.ReadFile(serverconf) @@ -231,13 +230,13 @@ func Test_SyncNewerFromNatsResolverWs(t *testing.T) { ports := ts.RunServerWithConfig(t, serverconf) require.NotNil(t, ports) // only after server start as ports are not yet known in tests - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", ports.WebSocket[0]) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--account-jwt-server-url", ports.WebSocket[0]}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createPullCmd(), "--all") + _, err = ExecuteCmd(createPullCmd(), []string{"--all"}...) require.NoError(t, err) // again, this time with system account and user specified - _, _, err = ExecuteCmd(createPullCmd(), "--all", "--system-account", "SYS", "--system-user", "sys") + _, err = ExecuteCmd(createPullCmd(), []string{"--all", "--system-account", "SYS", "--system-user", "sys"}...) require.NoError(t, err) // claim now exists in nsc store claim2, err := ts.Store.ReadAccountClaim("acc-name") @@ -257,7 +256,7 @@ func Test_V2OperatorDoesntFail(t *testing.T) { require.NoError(t, err) // edit the jwt - _, _, err = ExecuteCmd(createPullCmd(), "-A") + _, err = ExecuteCmd(createPullCmd(), []string{"-A"}...) require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() @@ -276,9 +275,9 @@ func Test_V1OperatorDoesntFail(t *testing.T) { require.NoError(t, err) // edit the jwt - stdout, stderr, err := ExecuteCmd(createPullCmd(), "-A") - t.Log(stdout) - t.Log(stderr) + out, err := ExecuteCmd(createPullCmd(), []string{"-A"}...) + t.Log(out.Out) + t.Log(out.Err) require.NoError(t, err) oc, err := ts.Store.ReadOperatorClaim() diff --git a/cmd/push_test.go b/cmd/push_test.go index 07c3fab6..7eb4f413 100644 --- a/cmd/push_test.go +++ b/cmd/push_test.go @@ -18,15 +18,14 @@ package cmd import ( "bytes" "fmt" + "github.com/nats-io/jwt/v2" + "github.com/stretchr/testify/require" "os" "path/filepath" "regexp" "runtime" "strings" "testing" - - "github.com/nats-io/jwt/v2" - "github.com/stretchr/testify/require" ) func Test_SyncOK(t *testing.T) { @@ -40,11 +39,11 @@ func Test_SyncOK(t *testing.T) { ts.AddAccount(t, "A") // edit the jwt - _, _, err = ExecuteCmd(createEditAccount(), "--tag", "A") + _, err = ExecuteCmd(createEditAccount(), []string{"--tag", "A"}...) require.NoError(t, err) // sync the store - _, _, err = ExecuteCmd(createPushCmd(), "--account", "A") + _, err = ExecuteCmd(createPushCmd(), []string{"--account", "A"}...) require.NoError(t, err) // verify the tag was stored @@ -68,7 +67,7 @@ func Test_SyncNoURL(t *testing.T) { require.NoError(t, err) ts.Store.StoreClaim([]byte(token)) - _, _, err = ExecuteCmd(createPushCmd(), "--account", "A") + _, err = ExecuteCmd(createPushCmd(), []string{"--account", "A"}...) require.Error(t, err) require.Contains(t, err.Error(), "no account server url or nats-server url was provided by the operator jwt") } @@ -79,12 +78,13 @@ func Test_SyncNoServer(t *testing.T) { ts.AddAccount(t, "A") as.Close() - _, stderr, err := ExecuteCmd(createPushCmd(), "--account", "A") + out, err := ExecuteCmd(createPushCmd(), "--account", "A") require.Error(t, err) if runtime.GOOS == "windows" { - require.Contains(t, stderr, "connectex: No connection") + // connectex is the actual name + require.Contains(t, out.Err, "connectex: No connection") } else { - require.Contains(t, stderr, "connect: connection refused") + require.Contains(t, out.Err, "connect: connection refused") } } @@ -120,11 +120,11 @@ func Test_SyncManualServer(t *testing.T) { ts.AddAccount(t, "A") // edit the jwt - _, _, err = ExecuteCmd(createEditAccount(), "--tag", "A") + _, err = ExecuteCmd(createEditAccount(), []string{"--tag", "A"}...) require.NoError(t, err) // sync the store - _, _, err = ExecuteCmd(createPushCmd(), "--account", "A", "--account-jwt-server-url", as.URL) + _, err = ExecuteCmd(createPushCmd(), []string{"--account", "A", "--account-jwt-server-url", as.URL}...) require.NoError(t, err) // verify the tag was stored @@ -141,11 +141,11 @@ func deleteSetup(t *testing.T, del bool) (string, []string, *TestStore) { ts.AddAccount(t, "AC1") ts.AddAccount(t, "AC2") - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--system-account", "SYS") + _, err := ExecuteCmd(createEditOperatorCmd(), "--system-account", "SYS") require.NoError(t, err) serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--nats-resolver", "--config-file", serverconf) + _, err = ExecuteCmd(createServerConfigCmd(), "--nats-resolver", "--config-file", serverconf) require.NoError(t, err) // modify the generated file so testing becomes easier by knowing where the jwt directory is @@ -160,18 +160,18 @@ func deleteSetup(t *testing.T, del bool) (string, []string, *TestStore) { ports := ts.RunServerWithConfig(t, serverconf) require.NotNil(t, ports) // only after server start as ports are not yet known in tests - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", ports.Nats[0]) + _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", ports.Nats[0]) require.NoError(t, err) - _, _, err = ExecuteCmd(createPushCmd(), "--all") + _, err = ExecuteCmd(createPushCmd(), "--all") require.NoError(t, err) // test to assure AC1/AC2/SYS where pushed filesPre, err := filepath.Glob(dir + string(os.PathSeparator) + "*.jwt") require.NoError(t, err) require.Equal(t, len(filesPre), 3) - _, _, err = ExecuteCmd(createDeleteAccountCmd(), "--name", "AC2") + _, err = ExecuteCmd(createDeleteAccountCmd(), "--name", "AC2") require.NoError(t, err) // exists as nsc has a bad default account now (is not pushed, hence not in file counts) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "AC3") + _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "AC3") require.NoError(t, err) return dir, filesPre, ts } @@ -184,8 +184,8 @@ func Test_SyncNatsResolverDeleteNoOperatorKey(t *testing.T) { require.NoError(t, err) require.NoError(t, ts.KeyStore.Remove(opk)) - _, stderr, err := ExecuteCmd(createPushCmd(), "--prune") - t.Log(stderr) + out, err := ExecuteCmd(createPushCmd(), []string{"--prune"}...) + t.Log(out.Err) require.Error(t, err) } @@ -203,7 +203,7 @@ func Test_SyncNatsResolverDeleteOperatorKeyInFlag(t *testing.T) { cmd := createPushCmd() HoistRootFlags(cmd) - _, _, err = ExecuteCmd(cmd, "--prune", "-K", string(seed)) + _, err = ExecuteCmd(cmd, []string{"--prune", "-K", string(seed)}...) require.NoError(t, err) } @@ -211,7 +211,7 @@ func Test_SyncNatsResolverDelete(t *testing.T) { dir, filesPre, ts := deleteSetup(t, true) defer ts.Done(t) - _, _, err := ExecuteCmd(createPushCmd(), "--prune") + _, err := ExecuteCmd(createPushCmd(), []string{"--prune"}...) require.NoError(t, err) // test to assure AC1/SYS where pushed/pruned filesPost, err := filepath.Glob(dir + string(os.PathSeparator) + "*.jwt") @@ -237,7 +237,7 @@ func Test_SyncNatsResolverExplicitDelete(t *testing.T) { dir, filesPre, ts := deleteSetup(t, true) defer os.Remove(dir) defer ts.Done(t) - _, _, err := ExecuteCmd(createPushCmd(), "--account-removal", "AC1") + _, err := ExecuteCmd(createPushCmd(), []string{"--account-removal", "AC1"}...) require.NoError(t, err) // test to assure AC1/SYS where pushed/pruned filesPost, err := filepath.Glob(dir + string(os.PathSeparator) + "*.jwt") @@ -263,39 +263,39 @@ func Test_SyncNatsResolverDiff(t *testing.T) { dir, _, ts := deleteSetup(t, true) defer os.Remove(dir) defer ts.Done(t) - _, stdErr, err := ExecuteCmd(createPushCmd(), "--diff") + out, err := ExecuteCmd(createPushCmd(), "--diff") require.NoError(t, err) - require.Contains(t, stdErr, "only exists in server") - require.Contains(t, stdErr, "named AC1 exists") - require.Contains(t, stdErr, "named SYS exists") + require.Contains(t, out.Out, "only exists in server") + require.Contains(t, out.Out, "named AC1 exists") + require.Contains(t, out.Out, "named SYS exists") re := regexp.MustCompile("[A-Z0-9]* named AC1 exists") - line := re.FindString(stdErr) + line := re.FindString(out.Out) accId := strings.TrimSuffix(line, " named AC1 exists") - _, _, err = ExecuteCmd(createPushCmd(), "--account-removal", accId) + out, err = ExecuteCmd(createPushCmd(), "--account-removal", accId) require.NoError(t, err) filesDeleted, err := filepath.Glob(dir + string(os.PathSeparator) + accId + ".jwt.deleted") require.NoError(t, err) require.Equal(t, 1, len(filesDeleted)) - _, stdErr, err = ExecuteCmd(createPushCmd(), "--diff") + out, err = ExecuteCmd(createPushCmd(), "--diff") require.NoError(t, err) - require.Contains(t, stdErr, "only exists in server") - require.NotContains(t, stdErr, "named AC1 exists") - require.Contains(t, stdErr, "named SYS exists") + require.Contains(t, out.Out, "only exists in server") + require.NotContains(t, out.Out, "named AC1 exists") + require.Contains(t, out.Out, "named SYS exists") } func Test_SyncNatsResolverDeleteSYS(t *testing.T) { dir, filesPre, ts := deleteSetup(t, true) defer os.Remove(dir) defer ts.Done(t) - _, _, err := ExecuteCmd(createDeleteAccountCmd(), "--name", "SYS") + _, err := ExecuteCmd(createDeleteAccountCmd(), []string{"--name", "SYS"}...) require.NoError(t, err) // exists as nsc has a bad default account now (is not pushed, hence not in file counts) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "AC4") + _, err = ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "AC4"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createPushCmd(), "--prune") // will fail as system acc can't be deleted - require.Error(t, err) // this will actually not hit the server as the system account is already deleted + _, err = ExecuteCmd(createPushCmd(), []string{"--prune"}...) // will fail as system acc can't be deleted + require.Error(t, err) // this will actually not hit the server as the system account is already deleted filesPost, err := filepath.Glob(dir + string(os.PathSeparator) + "*.jwt") require.NoError(t, err) require.Equal(t, 3, len(filesPost)) @@ -306,7 +306,7 @@ func Test_SyncNatsResolverNoDelete(t *testing.T) { dir, filesPre, ts := deleteSetup(t, false) defer os.Remove(dir) defer ts.Done(t) - _, _, err := ExecuteCmd(createPushCmd(), "--prune") + _, err := ExecuteCmd(createPushCmd(), []string{"--prune"}...) require.Error(t, err) // test to assure that pruning did not happen filesPost, err := filepath.Glob(dir + string(os.PathSeparator) + "*.jwt") @@ -318,12 +318,12 @@ func Test_SyncNatsResolverNoDelete(t *testing.T) { func Test_SyncBadUrl(t *testing.T) { ts := NewEmptyStore(t) defer ts.Done(t) - _, _, err := ExecuteCmd(createAddOperatorCmd(), "--name", "OP", "--sys") + _, err := ExecuteCmd(createAddOperatorCmd(), "--name", "OP", "--sys") require.NoError(t, err) serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--nats-resolver", "--config-file", serverconf) + _, err = ExecuteCmd(createServerConfigCmd(), "--nats-resolver", "--config-file", serverconf) require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "AC1") + _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "AC1") require.NoError(t, err) // modify the generated file so testing becomes easier by knowing where the jwt directory is data, err := os.ReadFile(serverconf) @@ -336,17 +336,17 @@ func Test_SyncBadUrl(t *testing.T) { require.NotNil(t, ports) // deliberately test if http push to a nats server kills it or not badUrl := strings.ReplaceAll(ports.Nats[0], "nats://", "http://") - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", badUrl) + _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", badUrl) require.NoError(t, err) - _, errOut, err := ExecuteCmd(createPushCmd(), "--all") + out, err := ExecuteCmd(createPushCmd(), "--all") require.Error(t, err) - require.Contains(t, errOut, `Post "`+badUrl) + require.Contains(t, out.Err, `Post "`+badUrl) // Fix bad url - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", ports.Nats[0]) + _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", ports.Nats[0]) require.NoError(t, err) // Try again, thus also testing if the server is still around // Provide explicit system account user to connect - _, _, err = ExecuteCmd(createPushCmd(), "--all", "--system-account", "SYS", "--system-user", "sys") + _, err = ExecuteCmd(createPushCmd(), "--all", "--system-account", "SYS", "--system-user", "sys") require.NoError(t, err) // test to assure AC1/AC2/SYS where pushed filesPre, err := filepath.Glob(dir + string(os.PathSeparator) + "*.jwt") @@ -357,12 +357,12 @@ func Test_SyncBadUrl(t *testing.T) { func Test_SyncWs(t *testing.T) { ts := NewEmptyStore(t) defer ts.Done(t) - _, _, err := ExecuteCmd(createAddOperatorCmd(), "--name", "OP", "--sys") + _, err := ExecuteCmd(createAddOperatorCmd(), []string{"--name", "OP", "--sys"}...) require.NoError(t, err) serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--nats-resolver", "--config-file", serverconf) + _, err = ExecuteCmd(createServerConfigCmd(), []string{"--nats-resolver", "--config-file", serverconf}...) require.NoError(t, err) - _, _, err = ExecuteCmd(CreateAddAccountCmd(), "--name", "AC1") + _, err = ExecuteCmd(CreateAddAccountCmd(), []string{"--name", "AC1"}...) require.NoError(t, err) // modify the generated file so testing becomes easier by knowing where the jwt directory is data, err := os.ReadFile(serverconf) @@ -379,11 +379,11 @@ func Test_SyncWs(t *testing.T) { require.NoError(t, err) ports := ts.RunServerWithConfig(t, serverconf) require.NotNil(t, ports) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--account-jwt-server-url", ports.WebSocket[0]) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--account-jwt-server-url", ports.WebSocket[0]}...) require.NoError(t, err) // Try again, thus also testing if the server is still around // Provide explicit system account user to connect - _, _, err = ExecuteCmd(createPushCmd(), "--all", "--system-account", "SYS", "--system-user", "sys") + _, err = ExecuteCmd(createPushCmd(), []string{"--all", "--system-account", "SYS", "--system-user", "sys"}...) require.NoError(t, err) // test to assure AC1/AC2/SYS where pushed filesPre, err := filepath.Glob(dir + string(os.PathSeparator) + "*.jwt") diff --git a/cmd/reissueoperator_test.go b/cmd/reissueoperator_test.go index f2cdd821..eff3dfab 100644 --- a/cmd/reissueoperator_test.go +++ b/cmd/reissueoperator_test.go @@ -16,9 +16,8 @@ package cmd import ( - "testing" - "github.com/stretchr/testify/require" + "testing" ) func Test_ReIssue(t *testing.T) { @@ -26,7 +25,7 @@ func Test_ReIssue(t *testing.T) { defer ts.Done(t) op1, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) - _, _, err = ExecuteCmd(createReIssueOperatorCmd()) + _, err = ExecuteCmd(createReIssueOperatorCmd(), []string{}...) require.NoError(t, err) op2, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -35,17 +34,17 @@ func Test_ReIssue(t *testing.T) { // add testing account ts.AddAccount(t, "A") - _, stderr, err := ExecuteCmd(createReIssueOperatorCmd(), "--convert-to-signing-key") + out, err := ExecuteCmd(createReIssueOperatorCmd(), "--convert-to-signing-key") require.NoError(t, err) op3, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) require.NotEqual(t, op2.Subject, op3.Subject) require.Equal( t, - stderr, "[ OK ] operator \"O\" successfully changed identity to: "+op3.Subject+"\n"+ "[ OK ] old operator key \""+op2.Subject+"\" turned into signing key\n"+ "all jobs succeeded\n", + out.Out, ) require.Len(t, op3.SigningKeys, 1) require.True(t, op3.SigningKeys.Contains(op2.Subject)) @@ -54,7 +53,7 @@ func Test_ReIssue(t *testing.T) { require.NoError(t, err) require.True(t, op3.DidSign(ac)) - _, _, err = ExecuteCmd(createReIssueOperatorCmd(), "--name", "O") + _, err = ExecuteCmd(createReIssueOperatorCmd(), "--name", "O") require.NoError(t, err) op4, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -82,7 +81,7 @@ func Test_ReIssueWithKey(t *testing.T) { cmd := createReIssueOperatorCmd() HoistRootFlags(cmd) - _, stderr, err := ExecuteCmd(cmd, "-K", string(seed)) + out, err := ExecuteCmd(cmd, "-K", string(seed)) require.NoError(t, err) op2, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -90,10 +89,10 @@ func Test_ReIssueWithKey(t *testing.T) { require.Equal(t, pub, op2.Subject) require.Equal( t, - stderr, "[ OK ] operator \"O\" successfully changed identity to: "+pub+"\n"+ "[ OK ] account \"A\" re-signed\n"+ "all jobs succeeded\n", + out.Out, ) ac, err := ts.Store.ReadAccountClaim("A") @@ -110,7 +109,7 @@ func Test_ReIssueStrict(t *testing.T) { // add testing account ts.AddAccount(t, "A") - _, _, err = ExecuteCmd(createReIssueOperatorCmd(), "--convert-to-signing-key") + _, err = ExecuteCmd(createReIssueOperatorCmd(), []string{"--convert-to-signing-key"}...) require.NoError(t, err) op3, err := ts.Store.ReadOperatorClaim() require.NoError(t, err) @@ -121,8 +120,8 @@ func Test_ReIssueStrict(t *testing.T) { require.NoError(t, err) require.True(t, op3.DidSign(ac)) - _, _, err = ExecuteCmd(createEditOperatorCmd(), "--require-signing-keys") + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--require-signing-keys"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createReIssueOperatorCmd(), "--convert-to-signing-key") + _, err = ExecuteCmd(createReIssueOperatorCmd(), []string{"--convert-to-signing-key"}...) require.NoError(t, err) } diff --git a/cmd/rename_test.go b/cmd/rename_test.go index bf64377e..cf1aa224 100644 --- a/cmd/rename_test.go +++ b/cmd/rename_test.go @@ -16,18 +16,16 @@ package cmd import ( - "testing" - "github.com/nats-io/jwt/v2" - "github.com/stretchr/testify/require" + "testing" ) func Test_RenameAccountRequiresOK(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRenameAccountCmd(), "A", "B") + _, err := ExecuteCmd(createRenameAccountCmd(), []string{"A", "B"}...) require.Error(t, err) require.Contains(t, err.Error(), "required flag \"OK\" not set") } @@ -37,7 +35,7 @@ func Test_RenameAccountNoUsers(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") pk := ts.GetAccountPublicKey(t, "A") - _, _, err := ExecuteCmd(createRenameAccountCmd(), "A", "B", "--OK") + _, err := ExecuteCmd(createRenameAccountCmd(), []string{"A", "B", "--OK"}...) require.NoError(t, err) _, err = ts.Store.ReadAccountClaim("A") @@ -59,7 +57,7 @@ func Test_RenameAccountUsers(t *testing.T) { require.FileExists(t, ts.KeyStore.CalcUserCredsPath("A", "aa")) require.FileExists(t, ts.KeyStore.CalcUserCredsPath("A", "bb")) - _, _, err := ExecuteCmd(createRenameAccountCmd(), "A", "B", "--OK") + _, err := ExecuteCmd(createRenameAccountCmd(), []string{"A", "B", "--OK"}...) require.NoError(t, err) _, err = ts.Store.ReadAccountClaim("A") @@ -81,7 +79,7 @@ func Test_RenameAccountDuplicate(t *testing.T) { ts.AddAccount(t, "A") ts.AddAccount(t, "B") - _, _, err := ExecuteCmd(createRenameAccountCmd(), "A", "B", "--OK") + _, err := ExecuteCmd(createRenameAccountCmd(), []string{"A", "B", "--OK"}...) require.Error(t, err) } @@ -99,7 +97,7 @@ func Test_RenameManagedAccount(t *testing.T) { require.Equal(t, pk, ac.Subject) require.Equal(t, "A", ac.Name) - _, _, err = ExecuteCmd(createRenameAccountCmd(), "A", "B", "--OK") + _, err = ExecuteCmd(createRenameAccountCmd(), []string{"A", "B", "--OK"}...) require.NoError(t, err) bc, err := jwt.DecodeAccountClaims(string(m[pk])) require.NoError(t, err) diff --git a/cmd/reqtool.go b/cmd/reqtool.go index 42be5c8b..5563ac97 100644 --- a/cmd/reqtool.go +++ b/cmd/reqtool.go @@ -158,6 +158,6 @@ func (p *ReqParams) Run(ctx ActionCtx) (store.Status, error) { if encryptFlag { msg = maybeDecryptMessage(seed, msg) } - ctx.CurrentCmd().Printf("received reply: [%v] : '%s'\n", msg.Subject, string(msg.Data)) - return nil, nil + _, err = fmt.Fprintf(ctx.CurrentCmd().OutOrStdout(), "received reply: [%v] : '%s'\n", msg.Subject, string(msg.Data)) + return nil, err } diff --git a/cmd/revoke_clearactivation_test.go b/cmd/revoke_clearactivation_test.go index 2edcb070..b64de113 100644 --- a/cmd/revoke_clearactivation_test.go +++ b/cmd/revoke_clearactivation_test.go @@ -16,11 +16,10 @@ package cmd import ( - "testing" - "time" - "github.com/nats-io/jwt/v2" "github.com/stretchr/testify/require" + "testing" + "time" ) func TestClearRevokeActivation(t *testing.T) { @@ -32,7 +31,7 @@ func TestClearRevokeActivation(t *testing.T) { _, pub, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--subject", "foo.bar", "--target-account", pub) + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--subject", "foo.bar", "--target-account", pub}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -43,7 +42,7 @@ func TestClearRevokeActivation(t *testing.T) { require.True(t, exp.Revocations.IsRevoked(pub, time.Unix(0, 0))) } - _, _, err = ExecuteCmd(createClearRevokeActivationCmd(), "--subject", "foo.bar", "--target-account", pub) + _, err = ExecuteCmd(createClearRevokeActivationCmd(), []string{"--subject", "foo.bar", "--target-account", pub}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -70,7 +69,7 @@ func TestClearRevokeActivationInteractive(t *testing.T) { input := []interface{}{1, true, 0, pub, "1000"} // second account "B" cmd := createRevokeActivationCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, input, "-i") + _, err := ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -89,7 +88,7 @@ func TestClearRevokeActivationInteractive(t *testing.T) { input = []interface{}{1, true, 0, 0} // second account "B" cmd = createClearRevokeActivationCmd() HoistRootFlags(cmd) - _, _, err = ExecuteInteractiveCmd(cmd, input, "-i") + _, err = ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("B") @@ -104,7 +103,7 @@ func TestClearRevokeActivationNoExports(t *testing.T) { ts := NewTestStore(t, "test") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createClearRevokeActivationCmd()) + _, err := ExecuteCmd(createClearRevokeActivationCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "account \"A\" doesn't have exports") } @@ -114,7 +113,7 @@ func TestClearRevokeActivationNoServiceExports(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "foo.>", 0, false) - _, _, err := ExecuteCmd(createClearRevokeActivationCmd(), "--service") + _, err := ExecuteCmd(createClearRevokeActivationCmd(), []string{"--service"}...) require.Error(t, err) require.Contains(t, err.Error(), "account \"A\" doesn't have service exports") } @@ -124,7 +123,7 @@ func TestClearRevokeActivationNoStreamExports(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "q", 0, false) - _, _, err := ExecuteCmd(createClearRevokeActivationCmd()) + _, err := ExecuteCmd(createClearRevokeActivationCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "account \"A\" doesn't have stream exports") } @@ -134,7 +133,7 @@ func TestClearRevokeActivationServiceNoExports(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "foo.>", 0, false) - _, _, err := ExecuteCmd(createClearRevokeActivationCmd(), "--service") + _, err := ExecuteCmd(createClearRevokeActivationCmd(), []string{"--service"}...) require.Error(t, err) require.Contains(t, err.Error(), "account \"A\" doesn't have service exports") } @@ -145,7 +144,7 @@ func TestClearRevokeActivationInteractiveServiceNoRevocations(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "q", 0, false) input := []interface{}{true, 0} - _, _, err := ExecuteInteractiveCmd(createClearRevokeActivationCmd(), input) + _, err := ExecuteInteractiveCmd(createClearRevokeActivationCmd(), input) require.Error(t, err) require.Contains(t, err.Error(), "service export q doesn't have revocations") } @@ -156,7 +155,7 @@ func TestClearRevokeActivationInteractiveStreamNoRevocations(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "q", 0, false) input := []interface{}{false, 0} - _, _, err := ExecuteInteractiveCmd(createClearRevokeActivationCmd(), input) + _, err := ExecuteInteractiveCmd(createClearRevokeActivationCmd(), input) require.Error(t, err) require.Contains(t, err.Error(), "stream export q doesn't have revocations") } @@ -166,9 +165,9 @@ func TestClearRevokeActivationDefault(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "s", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--target-account", "*") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--target-account", "*"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createClearRevokeActivationCmd(), "--target-account", "*") + _, err = ExecuteCmd(createClearRevokeActivationCmd(), []string{"--target-account", "*"}...) require.NoError(t, err) } @@ -178,11 +177,11 @@ func TestClearRevokeActivationNotFound(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "s", 0, false) ts.AddExport(t, "A", jwt.Stream, "r", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--target-account", "*", "--subject", "s") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--target-account", "*", "--subject", "s"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeActivationCmd(), "--target-account", "*", "--subject", "r") + _, err = ExecuteCmd(createRevokeActivationCmd(), []string{"--target-account", "*", "--subject", "r"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createClearRevokeActivationCmd(), "--target-account", "*", "--subject", "k") + _, err = ExecuteCmd(createClearRevokeActivationCmd(), []string{"--target-account", "*", "--subject", "k"}...) require.Error(t, err) require.Contains(t, err.Error(), "unable to locate export") } @@ -193,9 +192,9 @@ func TestClearRevokeActivationSubjectRequired(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "s", 0, false) ts.AddExport(t, "A", jwt.Stream, "r", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--target-account", "*", "--subject", "s") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--target-account", "*", "--subject", "s"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createClearRevokeActivationCmd(), "--target-account", "*") + _, err = ExecuteCmd(createClearRevokeActivationCmd(), []string{"--target-account", "*"}...) require.Error(t, err) require.Contains(t, err.Error(), "a subject is required") } diff --git a/cmd/revoke_listactivation.go b/cmd/revoke_listactivation.go index 5da5863b..42f0c156 100644 --- a/cmd/revoke_listactivation.go +++ b/cmd/revoke_listactivation.go @@ -204,5 +204,6 @@ func (p *RevokeListActivationParams) Run(ctx ActionCtx) (store.Status, error) { table.AddRow(pubKey, formatted) } - return nil, Write("--", []byte(table.Render())) + _, err := fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), table.Render()) + return nil, err } diff --git a/cmd/revoke_listactivation_test.go b/cmd/revoke_listactivation_test.go index 125b6ea4..5125bc1f 100644 --- a/cmd/revoke_listactivation_test.go +++ b/cmd/revoke_listactivation_test.go @@ -16,12 +16,11 @@ package cmd import ( + "github.com/nats-io/jwt/v2" + "github.com/stretchr/testify/require" "strings" "testing" "time" - - "github.com/nats-io/jwt/v2" - "github.com/stretchr/testify/require" ) func TestRevokeListActivation(t *testing.T) { @@ -35,41 +34,41 @@ func TestRevokeListActivation(t *testing.T) { _, pub, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--subject", "foo.bar", "--target-account", pub) + _, err := ExecuteCmd(createRevokeActivationCmd(), "--subject", "foo.bar", "--target-account", pub) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeActivationCmd(), "--subject", "bar", "--target-account", pub, "--service", "--at", "1001") + _, err = ExecuteCmd(createRevokeActivationCmd(), "--subject", "bar", "--target-account", pub, "--service", "--at", "1001") require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeActivationCmd(), "--subject", "public", "--target-account", pub, "--service", "--at", "2001") + _, err = ExecuteCmd(createRevokeActivationCmd(), "--subject", "public", "--target-account", pub, "--service", "--at", "2001") require.NoError(t, err) - stdout, _, err := ExecuteCmd(createRevokeListActivationCmd(), "--subject", "foo.bar") + stdout, err := ExecuteCmd(createRevokeListActivationCmd(), "--subject", "foo.bar") require.NoError(t, err) - require.True(t, strings.Contains(stdout, pub)) - require.False(t, strings.Contains(stdout, time.Unix(1001, 0).Format(time.RFC1123))) - require.False(t, strings.Contains(stdout, time.Unix(2001, 0).Format(time.RFC1123))) + require.True(t, strings.Contains(stdout.Out, pub)) + require.False(t, strings.Contains(stdout.Out, time.Unix(1001, 0).Format(time.RFC1123))) + require.False(t, strings.Contains(stdout.Out, time.Unix(2001, 0).Format(time.RFC1123))) - stdout, _, err = ExecuteCmd(createRevokeListActivationCmd(), "--subject", "bar", "--service") + stdout, err = ExecuteCmd(createRevokeListActivationCmd(), "--subject", "bar", "--service") require.NoError(t, err) - require.True(t, strings.Contains(stdout, pub)) - require.True(t, strings.Contains(stdout, time.Unix(1001, 0).Format(time.RFC1123))) - require.False(t, strings.Contains(stdout, time.Unix(2001, 0).Format(time.RFC1123))) + require.True(t, strings.Contains(stdout.Out, pub)) + require.True(t, strings.Contains(stdout.Out, time.Unix(1001, 0).Format(time.RFC1123))) + require.False(t, strings.Contains(stdout.Out, time.Unix(2001, 0).Format(time.RFC1123))) - stdout, _, err = ExecuteCmd(createRevokeListActivationCmd(), "--subject", "public", "--service") + stdout, err = ExecuteCmd(createRevokeListActivationCmd(), "--subject", "public", "--service") require.NoError(t, err) - require.True(t, strings.Contains(stdout, pub)) - require.False(t, strings.Contains(stdout, time.Unix(1001, 0).Format(time.RFC1123))) - require.True(t, strings.Contains(stdout, time.Unix(2001, 0).Format(time.RFC1123))) + require.True(t, strings.Contains(stdout.Out, pub)) + require.False(t, strings.Contains(stdout.Out, time.Unix(1001, 0).Format(time.RFC1123))) + require.True(t, strings.Contains(stdout.Out, time.Unix(2001, 0).Format(time.RFC1123))) } func TestRevokeListActivationNoAccount(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteInteractiveCmd(createRevokeListActivationCmd(), []interface{}{}) + _, err := ExecuteInteractiveCmd(createRevokeListActivationCmd(), []interface{}{}) require.Error(t, err) require.Contains(t, err.Error(), "no accounts defined") } @@ -77,7 +76,7 @@ func TestRevokeListActivationNoAccount(t *testing.T) { func TestRevokeListActivationNoAccountInteractive(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, _, err := ExecuteCmd(createRevokeListActivationCmd()) + _, err := ExecuteCmd(createRevokeListActivationCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "an account is required") } @@ -86,7 +85,7 @@ func TestRevokeListActivationNoExport(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRevokeListActivationCmd(), "--service") + _, err := ExecuteCmd(createRevokeListActivationCmd(), []string{"--service"}...) require.Error(t, err) require.Contains(t, err.Error(), "doesn't have exports") } @@ -96,7 +95,7 @@ func TestRevokeListActivationNoServiceExport(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "s", 0, false) - _, _, err := ExecuteCmd(createRevokeListActivationCmd(), "--service") + _, err := ExecuteCmd(createRevokeListActivationCmd(), []string{"--service"}...) require.Error(t, err) require.Contains(t, err.Error(), "doesn't have service exports") } @@ -106,7 +105,7 @@ func TestRevokeListActivationNoStreamExport(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "s", 0, false) - _, _, err := ExecuteCmd(createRevokeListActivationCmd()) + _, err := ExecuteCmd(createRevokeListActivationCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "doesn't have stream exports") } @@ -116,9 +115,9 @@ func TestRevokeListActivationDefaultExport(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "s", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--service", "--target-account", "*") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--service", "--target-account", "*"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeListActivationCmd(), "--service") + _, err = ExecuteCmd(createRevokeListActivationCmd(), []string{"--service"}...) require.NoError(t, err) } @@ -128,11 +127,11 @@ func TestRevokeListActivationNoDefaultExport(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "s", 0, false) ts.AddExport(t, "A", jwt.Service, "r", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--service", "--target-account", "*", "--subject", "s") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--service", "--target-account", "*", "--subject", "s"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeActivationCmd(), "--service", "--target-account", "*", "--subject", "r") + _, err = ExecuteCmd(createRevokeActivationCmd(), []string{"--service", "--target-account", "*", "--subject", "r"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeListActivationCmd(), "--service") + _, err = ExecuteCmd(createRevokeListActivationCmd(), []string{"--service"}...) require.Error(t, err) require.Contains(t, err.Error(), "a subject is required") } @@ -143,11 +142,11 @@ func TestRevokeListActivationExportNotFound(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "s", 0, false) ts.AddExport(t, "A", jwt.Service, "r", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--service", "--target-account", "*", "--subject", "s") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--service", "--target-account", "*", "--subject", "s"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeActivationCmd(), "--service", "--target-account", "*", "--subject", "r") + _, err = ExecuteCmd(createRevokeActivationCmd(), []string{"--service", "--target-account", "*", "--subject", "r"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeListActivationCmd(), "--service", "--subject", "x") + _, err = ExecuteCmd(createRevokeListActivationCmd(), []string{"--service", "--subject", "x"}...) require.Error(t, err) require.Contains(t, err.Error(), "unable to locate export") } @@ -157,7 +156,7 @@ func TestRevokeListActivationHasNoRevocations(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "s", 0, false) - _, _, err := ExecuteCmd(createRevokeListActivationCmd(), "--service", "--subject", "s") + _, err := ExecuteCmd(createRevokeListActivationCmd(), []string{"--service", "--subject", "s"}...) require.Error(t, err) require.Contains(t, err.Error(), "service s has no revocations") } @@ -167,9 +166,9 @@ func TestRevokeListActivationInteractive(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "s", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--service", "--subject", "s", "--target-account", "*") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--service", "--subject", "s", "--target-account", "*"}...) require.NoError(t, err) args := []interface{}{true, 0} - _, _, err = ExecuteInteractiveCmd(createRevokeListActivationCmd(), args) + _, err = ExecuteInteractiveCmd(createRevokeListActivationCmd(), args) require.NoError(t, err) } diff --git a/cmd/revoke_listusers.go b/cmd/revoke_listusers.go index 773515b3..29abd576 100644 --- a/cmd/revoke_listusers.go +++ b/cmd/revoke_listusers.go @@ -110,5 +110,6 @@ func (p *RevokeListUserParams) Run(ctx ActionCtx) (store.Status, error) { formatted := t.Format(time.RFC1123) table.AddRow(pubKey, formatted) } - return nil, Write("--", []byte(table.Render())) + _, err := fmt.Fprintln(ctx.CurrentCmd().OutOrStdout(), table.Render()) + return nil, err } diff --git a/cmd/revoke_listusers_test.go b/cmd/revoke_listusers_test.go index 573372d3..66a0fd8d 100644 --- a/cmd/revoke_listusers_test.go +++ b/cmd/revoke_listusers_test.go @@ -16,13 +16,11 @@ package cmd import ( + "github.com/nats-io/jwt/v2" + "github.com/stretchr/testify/require" "strings" "testing" "time" - - "github.com/nats-io/jwt/v2" - - "github.com/stretchr/testify/require" ) func TestRevokeListUsers(t *testing.T) { @@ -34,30 +32,30 @@ func TestRevokeListUsers(t *testing.T) { ts.AddUser(t, "A", "two") ts.AddUser(t, "A", "three") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "--name", "one", "--at", "1001") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"--name", "one", "--at", "1001"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeUserCmd(), "--name", "two", "--at", "2001") + _, err = ExecuteCmd(createRevokeUserCmd(), []string{"--name", "two", "--at", "2001"}...) require.NoError(t, err) - stdout, _, err := ExecuteCmd(createRevokeListUsersCmd()) + out, err := ExecuteCmd(createRevokeListUsersCmd()) require.NoError(t, err) u, err := ts.Store.ReadUserClaim("A", "one") require.NoError(t, err) - require.True(t, strings.Contains(stdout, u.Subject)) - require.True(t, strings.Contains(stdout, time.Unix(1001, 0).Format(time.RFC1123))) + require.True(t, strings.Contains(out.Out, u.Subject)) + require.True(t, strings.Contains(out.Out, time.Unix(1001, 0).Format(time.RFC1123))) u, err = ts.Store.ReadUserClaim("A", "two") require.NoError(t, err) - require.True(t, strings.Contains(stdout, u.Subject)) - require.True(t, strings.Contains(stdout, time.Unix(2001, 0).Format(time.RFC1123))) + require.True(t, strings.Contains(out.Out, u.Subject)) + require.True(t, strings.Contains(out.Out, time.Unix(2001, 0).Format(time.RFC1123))) } func TestRevokeListUsersNoAccount(t *testing.T) { ts := NewTestStore(t, "revoke_clear_user") defer ts.Done(t) - _, _, err := ExecuteInteractiveCmd(createRevokeListUsersCmd(), []interface{}{}) + _, err := ExecuteInteractiveCmd(createRevokeListUsersCmd(), []interface{}{}) require.Error(t, err) require.Contains(t, err.Error(), "no accounts defined") } @@ -66,7 +64,7 @@ func TestRevokeListUsersNoRevocations(t *testing.T) { ts := NewTestStore(t, "revoke_clear_user") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRevokeListUsersCmd()) + _, err := ExecuteCmd(createRevokeListUsersCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "does not have revoked users") } @@ -75,14 +73,14 @@ func TestRevokeListUsersAllUsers(t *testing.T) { ts := NewTestStore(t, "revoke_clear_user") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "-u", "*") + _, err := ExecuteCmd(createRevokeUserCmd(), "-u", "*") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) require.Contains(t, ac.Revocations, jwt.All) - stdout, _, err := ExecuteCmd(createRevokeListUsersCmd()) + out, err := ExecuteCmd(createRevokeListUsersCmd()) require.NoError(t, err) - require.Contains(t, stdout, "* [All Users]") + require.Contains(t, out.Out, "* [All Users]") } diff --git a/cmd/revokeactivation_test.go b/cmd/revokeactivation_test.go index 1793494b..51744194 100644 --- a/cmd/revokeactivation_test.go +++ b/cmd/revokeactivation_test.go @@ -16,11 +16,10 @@ package cmd import ( - "testing" - "time" - "github.com/nats-io/jwt/v2" "github.com/stretchr/testify/require" + "testing" + "time" ) func TestRevokeActivation(t *testing.T) { @@ -34,13 +33,13 @@ func TestRevokeActivation(t *testing.T) { _, pub, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--subject", "foo.bar", "--target-account", pub) + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--subject", "foo.bar", "--target-account", pub}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeActivationCmd(), "--subject", "bar", "--target-account", pub, "--service") + _, err = ExecuteCmd(createRevokeActivationCmd(), []string{"--subject", "bar", "--target-account", pub, "--service"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeActivationCmd(), "--subject", "public", "--target-account", pub, "--service") + _, err = ExecuteCmd(createRevokeActivationCmd(), []string{"--subject", "public", "--target-account", pub, "--service"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -62,10 +61,10 @@ func TestRevokeActivationAt(t *testing.T) { _, pub, _ := CreateAccountKey(t) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "--subject", "foo.bar", "--target-account", pub, "--at", "1000") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"--subject", "foo.bar", "--target-account", pub, "--at", "1000"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createRevokeActivationCmd(), "--subject", "bar", "--target-account", pub, "--service", "--at", "1000") + _, err = ExecuteCmd(createRevokeActivationCmd(), []string{"--subject", "bar", "--target-account", pub, "--service", "--at", "1000"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -94,7 +93,7 @@ func TestRevokeActivationForStreamInteractive(t *testing.T) { input := []interface{}{1, false, 0, pub, "1000"} // second account "B" cmd := createRevokeActivationCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, input, "-i") + _, err := ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -134,7 +133,7 @@ func TestRevokeActivationForServiceInteractive(t *testing.T) { input := []interface{}{1, true, 0, pub, "1000"} // second account "B" cmd := createRevokeActivationCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, input, "-i") + _, err := ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -162,7 +161,7 @@ func TestRevokeActivationNoExports(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "-t", "*") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"-t", "*"}...) require.Error(t, err) require.Contains(t, err.Error(), "doesn't have exports") } @@ -173,7 +172,7 @@ func TestRevokeActivationServiceNoExports(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "q", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "-t", "*") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"-t", "*"}...) require.Error(t, err) require.Contains(t, err.Error(), "doesn't have stream exports") } @@ -184,7 +183,7 @@ func TestRevokeActivationStreamNoExports(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Stream, "q", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "-t", "*", "--service") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"-t", "*", "--service"}...) require.Error(t, err) require.Contains(t, err.Error(), "doesn't have service exports") } @@ -196,7 +195,7 @@ func TestRevokeActivationSubjectRequired(t *testing.T) { ts.AddExport(t, "A", jwt.Service, "q", 0, false) ts.AddExport(t, "A", jwt.Service, "qq", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "-t", "*", "--service") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"-t", "*", "--service"}...) require.Error(t, err) require.Contains(t, err.Error(), "a subject is required") } @@ -207,7 +206,7 @@ func TestRevokeActivationExportNotFound(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "q", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "-t", "*", "--service", "--subject", "foo") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"-t", "*", "--service", "--subject", "foo"}...) require.Error(t, err) require.Contains(t, err.Error(), "unable to locate export") } @@ -218,7 +217,7 @@ func TestRevokeActivationDefaultSubject(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "q", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "-t", "*", "--service") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"-t", "*", "--service"}...) require.NoError(t, err) } @@ -228,7 +227,7 @@ func TestRevokeActivationAll(t *testing.T) { ts.AddAccount(t, "A") ts.AddExport(t, "A", jwt.Service, "q", 0, false) - _, _, err := ExecuteCmd(createRevokeActivationCmd(), "-t", "*", "--service", "--subject", "q") + _, err := ExecuteCmd(createRevokeActivationCmd(), []string{"-t", "*", "--service", "--subject", "q"}...) require.NoError(t, err) } @@ -239,7 +238,7 @@ func TestRevokeActivationBadInteractiveAt(t *testing.T) { ts.AddExport(t, "A", jwt.Service, "q", 0, false) input := []interface{}{true, 0, "*", "hello"} - _, _, err := ExecuteInteractiveCmd(createRevokeActivationCmd(), input) + _, err := ExecuteInteractiveCmd(createRevokeActivationCmd(), input) require.Error(t, err) require.Contains(t, err.Error(), `provided value "hello" is not`) } diff --git a/cmd/revokeclearuser_test.go b/cmd/revokeclearuser_test.go index 8ce82e5d..157320df 100644 --- a/cmd/revokeclearuser_test.go +++ b/cmd/revokeclearuser_test.go @@ -16,11 +16,9 @@ package cmd import ( - "testing" - cli "github.com/nats-io/cliprompts/v2" - "github.com/stretchr/testify/require" + "testing" ) func TestRevokeClearUser(t *testing.T) { @@ -32,7 +30,7 @@ func TestRevokeClearUser(t *testing.T) { ts.AddUser(t, "A", "two") ts.AddUser(t, "A", "three") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "--name", "one") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"--name", "one"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -43,7 +41,7 @@ func TestRevokeClearUser(t *testing.T) { require.NoError(t, err) require.Contains(t, ac.Revocations, u.Subject) - _, _, err = ExecuteCmd(createClearRevokeUserCmd(), "--name", "one") + _, err = ExecuteCmd(createClearRevokeUserCmd(), []string{"--name", "one"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -51,7 +49,7 @@ func TestRevokeClearUser(t *testing.T) { require.Len(t, ac.Revocations, 0) // error if not revoked - _, _, err = ExecuteCmd(createClearRevokeUserCmd(), "--name", "one") + _, err = ExecuteCmd(createClearRevokeUserCmd(), []string{"--name", "one"}...) require.Error(t, err) } @@ -66,7 +64,7 @@ func TestRevokeClearUserInteractive(t *testing.T) { ts.AddUser(t, "B", "one") ts.AddUser(t, "B", "two") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "--name", "one", "--account", "A") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"--name", "one", "--account", "A"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -82,7 +80,7 @@ func TestRevokeClearUserInteractive(t *testing.T) { cmd := createClearRevokeUserCmd() HoistRootFlags(cmd) cli.LogFn = t.Log - _, _, err = ExecuteInteractiveCmd(cmd, input, "-i") + _, err = ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -94,7 +92,7 @@ func TestClearRevokeUserUserAndKey(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createClearRevokeUserCmd(), "--name", "a", "--user-public-key", "UAUGJSHSTZY4ESHTL32CYYQNGT6MHXDQY6APMFMVRXWZN76RHE2IRN5O") + _, err := ExecuteCmd(createClearRevokeUserCmd(), []string{"--name", "a", "--user-public-key", "UAUGJSHSTZY4ESHTL32CYYQNGT6MHXDQY6APMFMVRXWZN76RHE2IRN5O"}...) require.Error(t, err) require.Contains(t, err.Error(), "user and user-public-key are mutually exclusive") } @@ -104,7 +102,7 @@ func TestClearRevokeUserNotFound(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createClearRevokeUserCmd(), "--name", "uu") + _, err := ExecuteCmd(createClearRevokeUserCmd(), []string{"--name", "uu"}...) require.Error(t, err) require.Contains(t, err.Error(), "not found") } @@ -114,9 +112,9 @@ func TestClearRevokeDefaultUser(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createRevokeUserCmd()) + _, err := ExecuteCmd(createRevokeUserCmd(), []string{}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createClearRevokeUserCmd()) + _, err = ExecuteCmd(createClearRevokeUserCmd(), []string{}...) require.NoError(t, err) } @@ -125,9 +123,9 @@ func TestClearRevokeRevocationNotFound(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createRevokeUserCmd()) + _, err := ExecuteCmd(createRevokeUserCmd(), []string{}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createClearRevokeUserCmd(), "-u", "*") + _, err = ExecuteCmd(createClearRevokeUserCmd(), []string{"-u", "*"}...) require.Error(t, err) require.Contains(t, err.Error(), "user with public key * is not revoked") } @@ -136,9 +134,9 @@ func TestClearRevokeAllUsers(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "-u", "*") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"-u", "*"}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createClearRevokeUserCmd(), "-u", "*") + _, err = ExecuteCmd(createClearRevokeUserCmd(), []string{"-u", "*"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") diff --git a/cmd/revokeuser_test.go b/cmd/revokeuser_test.go index 181dae72..6dc01c09 100644 --- a/cmd/revokeuser_test.go +++ b/cmd/revokeuser_test.go @@ -16,13 +16,11 @@ package cmd import ( + "github.com/nats-io/jwt/v2" + "github.com/stretchr/testify/require" "strconv" "testing" "time" - - "github.com/nats-io/jwt/v2" - - "github.com/stretchr/testify/require" ) func TestRevokeUser(t *testing.T) { @@ -34,7 +32,7 @@ func TestRevokeUser(t *testing.T) { ts.AddUser(t, "A", "two") ts.AddUser(t, "A", "three") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "--name", "one") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"--name", "one"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -45,7 +43,7 @@ func TestRevokeUser(t *testing.T) { require.NoError(t, err) require.True(t, ac.IsClaimRevoked(u)) - _, _, err = ExecuteCmd(createRevokeUserCmd(), "--name", "two") + _, err = ExecuteCmd(createRevokeUserCmd(), []string{"--name", "two"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -57,7 +55,7 @@ func TestRevokeUser(t *testing.T) { require.True(t, ac.IsClaimRevoked(u)) // Double doesn't do anything - _, _, err = ExecuteCmd(createRevokeUserCmd(), "--name", "two") + _, err = ExecuteCmd(createRevokeUserCmd(), []string{"--name", "two"}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -74,7 +72,7 @@ func TestRevokeUserAt(t *testing.T) { ts.AddUser(t, "A", "two") ts.AddUser(t, "A", "three") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "--name", "one", "--at", "1000") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"--name", "one", "--at", "1000"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -87,7 +85,7 @@ func TestRevokeUserAt(t *testing.T) { _, ok := ac.Revocations[u.Subject] require.True(t, ok) - _, _, err = ExecuteCmd(createRevokeUserCmd(), "--name", "two", "--at", strconv.Itoa(int(time.Now().Unix()))) + _, err = ExecuteCmd(createRevokeUserCmd(), []string{"--name", "two", "--at", strconv.Itoa(int(time.Now().Unix()))}...) require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -111,7 +109,7 @@ func Test_RevokeUserAccountNameRequired(t *testing.T) { ts.AddAccount(t, "B") ts.AddUser(t, "B", "one") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "--name", "one") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"--name", "one"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("B") @@ -139,7 +137,7 @@ func TestRevokeUserInteractive(t *testing.T) { input := []interface{}{0, true, 0, "0"} cmd := createRevokeUserCmd() HoistRootFlags(cmd) - _, _, err := ExecuteInteractiveCmd(cmd, input, "-i") + _, err := ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -153,7 +151,7 @@ func TestRevokeUserInteractive(t *testing.T) { cmd = createRevokeUserCmd() HoistRootFlags(cmd) input = []interface{}{0, false, keyToRevoke, "0"} - _, _, err = ExecuteInteractiveCmd(cmd, input, "-i") + _, err = ExecuteInteractiveCmd(cmd, input, "-i") require.NoError(t, err) ac, err = ts.Store.ReadAccountClaim("A") @@ -176,9 +174,9 @@ func TestRevokeUserByNkey(t *testing.T) { cmd := createRevokeUserCmd() HoistRootFlags(cmd) - _, _, err = ExecuteCmd(cmd, "-u", u.Subject) + _, err = ExecuteCmd(cmd, []string{"-u", u.Subject}...) require.NoError(t, err) - _, _, err = ExecuteCmd(cmd, "-u", keyToRevoke) + _, err = ExecuteCmd(cmd, []string{"-u", keyToRevoke}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -201,7 +199,7 @@ func TestRevokeUserNameKey(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "--name", "a", "--user-public-key", "UAUGJSHSTZY4ESHTL32CYYQNGT6MHXDQY6APMFMVRXWZN76RHE2IRN5O") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"--name", "a", "--user-public-key", "UAUGJSHSTZY4ESHTL32CYYQNGT6MHXDQY6APMFMVRXWZN76RHE2IRN5O"}...) require.Error(t, err) require.Contains(t, err.Error(), "user and user-public-key are mutually exclusive") } @@ -211,11 +209,11 @@ func TestRevokeUserNameNotFound(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "--name", "a") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"--name", "a"}...) require.Error(t, err) require.Contains(t, err.Error(), "not found") - _, _, err = ExecuteCmd(createRevokeUserCmd(), "--name", "U") + _, err = ExecuteCmd(createRevokeUserCmd(), []string{"--name", "U"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") require.NoError(t, err) @@ -229,7 +227,7 @@ func TestRevokeDefaultUser(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createRevokeUserCmd()) + _, err := ExecuteCmd(createRevokeUserCmd(), []string{}...) require.NoError(t, err) upk := ts.GetUserPublicKey(t, "A", "U") @@ -245,7 +243,7 @@ func TestRevokeUserRequired(t *testing.T) { ts.AddAccount(t, "A") ts.AddUser(t, "A", "U") ts.AddUser(t, "A", "Y") - _, _, err := ExecuteCmd(createRevokeUserCmd()) + _, err := ExecuteCmd(createRevokeUserCmd(), []string{}...) require.Error(t, err) require.Contains(t, err.Error(), "no default user available") } @@ -254,7 +252,7 @@ func TestRevokeAllUsers(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "-u", "*") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"-u", "*"}...) require.NoError(t, err) ac, err := ts.Store.ReadAccountClaim("A") @@ -266,7 +264,7 @@ func TestRevokeBadUnixTime(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "A") - _, _, err := ExecuteCmd(createRevokeUserCmd(), "-u", "*", "--at", "hello") + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"-u", "*", "--at", "hello"}...) require.Error(t, err) require.Contains(t, err.Error(), "invalid argument") } @@ -276,7 +274,7 @@ func TestRevokeRFC3339Time(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") at := time.Now() - _, _, err := ExecuteCmd(createRevokeUserCmd(), "-u", "*", "--at", at.Format(time.RFC3339)) + _, err := ExecuteCmd(createRevokeUserCmd(), []string{"-u", "*", "--at", at.Format(time.RFC3339)}...) require.NoError(t, err) c, err := ts.Store.ReadAccountClaim("A") @@ -290,7 +288,7 @@ func TestRevokeBadUnixTimeInteractive(t *testing.T) { defer ts.Done(t) ts.AddAccount(t, "A") input := []interface{}{"*", "hello"} - _, _, err := ExecuteInteractiveCmd(createRevokeUserCmd(), input) + _, err := ExecuteInteractiveCmd(createRevokeUserCmd(), input) require.Error(t, err) require.Contains(t, err.Error(), `provided value "hello" is not`) } diff --git a/cmd/rtttool.go b/cmd/rtttool.go index 1e991024..4816083f 100644 --- a/cmd/rtttool.go +++ b/cmd/rtttool.go @@ -109,14 +109,11 @@ func (p *RttParams) Run(ctx ActionCtx) (store.Status, error) { } defer nc.Close() - if err != nil { - return nil, err - } start := time.Now() if err := nc.Flush(); err != nil { return nil, err } rtt := time.Since(start) - ctx.CurrentCmd().Printf("round trip time to [%s] = %v\n", nc.ConnectedUrl(), rtt) - return nil, nil + _, err = fmt.Fprintf(ctx.CurrentCmd().OutOrStdout(), "round trip time to [%s] = %v\n", nc.ConnectedUrl(), rtt) + return nil, err } diff --git a/cmd/rtttool_test.go b/cmd/rtttool_test.go index 78ae4575..0c651a4e 100644 --- a/cmd/rtttool_test.go +++ b/cmd/rtttool_test.go @@ -30,7 +30,7 @@ func Test_RttTool(t *testing.T) { ts.AddUser(t, "A", "a") serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--mem-resolver", "--config-file", serverconf) + _, err = ExecuteCmd(createServerConfigCmd(), []string{"--mem-resolver", "--config-file", serverconf}...) require.NoError(t, err) var opts server.Options @@ -45,7 +45,7 @@ func Test_RttTool(t *testing.T) { } defer s.Shutdown() - _, stdErr, err := ExecuteCmd(createToolRTTCmd(), "--account", "A", "--user", "a") + out, err := ExecuteCmd(createToolRTTCmd(), "--account", "A", "--user", "a") require.NoError(t, err) - require.Contains(t, stdErr, "round trip time to [nats://127.0.0.1:4222]") + require.Contains(t, out.Out, "round trip time to [nats://127.0.0.1:4222]") } diff --git a/cmd/select_test.go b/cmd/select_test.go index 387b66a2..b2c1ea41 100644 --- a/cmd/select_test.go +++ b/cmd/select_test.go @@ -16,9 +16,8 @@ package cmd import ( - "testing" - "github.com/stretchr/testify/require" + "testing" ) func TestSelectAccount(t *testing.T) { @@ -26,23 +25,23 @@ func TestSelectAccount(t *testing.T) { ts := NewTestStore(t, "test") defer ts.Done(t) - _, _, err := ExecuteCmd(selectAccountCmd(), "A") + _, err := ExecuteCmd(selectAccountCmd(), []string{"A"}...) require.NotNil(err) ts.AddAccount(t, "A") ts.AddAccount(t, "B") - _, _, err = ExecuteCmd(selectAccountCmd(), "A") + _, err = ExecuteCmd(selectAccountCmd(), []string{"A"}...) require.Nil(err) conf := GetConfig() require.Equal(conf.Account, "A") - _, _, err = ExecuteCmd(selectAccountCmd(), "B") + _, err = ExecuteCmd(selectAccountCmd(), []string{"B"}...) require.Nil(err) conf = GetConfig() require.Equal(conf.Account, "B") - _, _, err = ExecuteCmd(selectAccountCmd(), "NO") + _, err = ExecuteCmd(selectAccountCmd(), []string{"NO"}...) require.NotNil(err) require.Contains(err.Error(), "\"NO\" not in accounts for operator") @@ -55,23 +54,23 @@ func TestSelectOperator(t *testing.T) { ts := NewTestStore(t, "test") defer ts.Done(t) - _, _, err := ExecuteCmd(selectOperatorCmd(), "test") + _, err := ExecuteCmd(selectOperatorCmd(), []string{"test"}...) require.Nil(err) ts.AddOperator(t, "test2") ts.AddOperator(t, "test3") - _, _, err = ExecuteCmd(selectOperatorCmd(), "test2") + _, err = ExecuteCmd(selectOperatorCmd(), []string{"test2"}...) require.Nil(err) conf := GetConfig() require.Equal(conf.Operator, "test2") - _, _, err = ExecuteCmd(selectOperatorCmd(), "test3") + _, err = ExecuteCmd(selectOperatorCmd(), []string{"test3"}...) require.Nil(err) conf = GetConfig() require.Equal(conf.Operator, "test3") - _, _, err = ExecuteCmd(selectOperatorCmd(), "NO") + _, err = ExecuteCmd(selectOperatorCmd(), []string{"NO"}...) require.NotNil(err) require.Contains(err.Error(), "operator \"NO\" not in") diff --git a/cmd/signerparams_test.go b/cmd/signerparams_test.go index df7a3092..1a2bda0b 100644 --- a/cmd/signerparams_test.go +++ b/cmd/signerparams_test.go @@ -148,7 +148,7 @@ func Test_SignerParamsSameDir(t *testing.T) { cwd, err := os.Getwd() require.NoError(t, err) require.NoError(t, os.Chdir(ts.Dir)) - _, _, err = ExecuteCmd(createSignerCmd(nkeys.PrefixByteOperator, false, ts.OperatorKey), "-K", filepath.Base(dest)) + _, err = ExecuteCmd(createSignerCmd(nkeys.PrefixByteOperator, false, ts.OperatorKey), []string{"-K", filepath.Base(dest)}...) require.NoError(t, os.Chdir(cwd)) require.NoError(t, err) } @@ -164,7 +164,7 @@ func Test_SignerParamsRelativePath(t *testing.T) { cwd, err := os.Getwd() require.NoError(t, err) require.NoError(t, os.Chdir(ts.StoreDir)) - _, _, err = ExecuteCmd(createSignerCmd(nkeys.PrefixByteOperator, false, ts.OperatorKey), "-K", filepath.Join("../", filepath.Base(dest))) + _, err = ExecuteCmd(createSignerCmd(nkeys.PrefixByteOperator, false, ts.OperatorKey), []string{"-K", filepath.Join("../", filepath.Base(dest))}...) require.NoError(t, os.Chdir(cwd)) require.NoError(t, err) } @@ -174,7 +174,7 @@ func Test_SignerParamsPathNotFound(t *testing.T) { defer ts.Done(t) require.NoError(t, os.Remove(ts.OperatorKeyPath)) - _, _, err := ExecuteCmd(createSignerCmd(nkeys.PrefixByteOperator, false, nil), "-K", ts.OperatorKeyPath) + _, err := ExecuteCmd(createSignerCmd(nkeys.PrefixByteOperator, false, nil), []string{"-K", ts.OperatorKeyPath}...) require.Error(t, err) require.Contains(t, err.Error(), "unable to resolve any of the following signing keys in the keystore") } @@ -202,7 +202,7 @@ func Test_SignerParamsHomePath(t *testing.T) { tfn := AbbrevHomePaths(fn) require.Equal(t, "~", tfn[:1]) - _, _, err = ExecuteCmd(createSignerCmd(nkeys.PrefixByteOperator, false, ts.OperatorKey), "-K", tfn) + _, err = ExecuteCmd(createSignerCmd(nkeys.PrefixByteOperator, false, ts.OperatorKey), []string{"-K", tfn}...) require.NoError(t, err) } @@ -213,13 +213,13 @@ func Test_SignerParamsSeed(t *testing.T) { ts.AddAccount(t, "A") s, pk, _ := CreateAccountKey(t) - _, stdErr, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "a", "-K", string(s)) + out, err := ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "a", "-K", string(s)}...) require.Error(t, err) - require.Contains(t, stdErr, "is not in the store") + require.Contains(t, out.Err, "is not in the store") - _, _, err = ExecuteCmd(createEditAccount(), "--sk", pk) + _, err = ExecuteCmd(createEditAccount(), []string{"--sk", pk}...) require.NoError(t, err) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--name", "a", "-K", string(s)) + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--name", "a", "-K", string(s)}...) require.NoError(t, err) } diff --git a/cmd/test.go b/cmd/test.go index 7abfe483..e0772ccc 100644 --- a/cmd/test.go +++ b/cmd/test.go @@ -17,7 +17,6 @@ package cmd import ( "bytes" - "fmt" "path/filepath" "sort" "strings" @@ -60,7 +59,8 @@ func createFlagTable() *cobra.Command { cmds.addCmd(v) } } - return Write("--", []byte(cmds.render())) + cmd.Println(cmds.render()) + return nil }, } return cmd @@ -92,7 +92,8 @@ func createWhatUsesFlag() *cobra.Command { cmds.addCmd(v) } } - cmds.find(args[0]) + found := cmds.find(args[0]) + cmd.Println(strings.Join(found, "\n")) return nil }, } @@ -176,15 +177,17 @@ func (t *flagTable) addCmd(cmd *cobra.Command) { t.commands = append(t.commands, c) } -func (t *flagTable) find(flag string) { +func (t *flagTable) find(flag string) []string { + var buf []string for _, c := range t.commands { m := c.flagMap for n := range m { if flag == m[n] || n == flag { - fmt.Println(c.name) + buf = append(buf, c.name) } } } + return buf } func (t *flagTable) render() string { diff --git a/cmd/test_test.go b/cmd/test_test.go index fec377d8..c998c056 100644 --- a/cmd/test_test.go +++ b/cmd/test_test.go @@ -14,10 +14,10 @@ func Test_FlagTable(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - stdout, _, err := ExecuteCmd(GetRootCmd(), "test", "flags") + out, err := ExecuteCmd(GetRootCmd(), "test", "flags") require.NoError(t, err) - require.Contains(t, stdout, "nsc validate") - require.Contains(t, stdout, "nsc add account") + require.Contains(t, out.Out, "nsc validate") + require.Contains(t, out.Out, "nsc add account") } func Test_WhoFlagTable(t *testing.T) { @@ -27,9 +27,9 @@ func Test_WhoFlagTable(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - stdout, _, err := ExecuteCmd(GetRootCmd(), "test", "whoflag", "allow-pub") + out, err := ExecuteCmd(GetRootCmd(), "test", "whoflag", "allow-pub") require.NoError(t, err) - require.Contains(t, stdout, "nsc add user") + require.Contains(t, out.Out, "nsc add user") } func Test_Doc(t *testing.T) { @@ -37,7 +37,7 @@ func Test_Doc(t *testing.T) { defer ts.Done(t) docs := filepath.Join(ts.Dir, "doc") - _, _, err := ExecuteCmd(GetRootCmd(), "test", "doc", docs) + _, err := ExecuteCmd(GetRootCmd(), []string{"test", "doc", docs}...) require.NoError(t, err) require.DirExists(t, docs) require.FileExists(t, filepath.Join(docs, "nsc_add.md")) diff --git a/cmd/timeparams.go b/cmd/timeparams.go index d5d3c38f..96f805ab 100644 --- a/cmd/timeparams.go +++ b/cmd/timeparams.go @@ -98,7 +98,7 @@ func (p *TimeParams) canParse(s string) error { func (p *TimeParams) Edit() error { var err error format := "valid from ('0' is always) - yyyy-mm-dd, #m(inutes), #h(ours), #d(ays), #w(eeks), #M(onths), #y(ears)" - p.Start, err = cli.Prompt("valid", p.Start, cli.Val(p.canParse), cli.Help(format)) + p.Start, err = cli.Prompt("valid from", p.Start, cli.Val(p.canParse), cli.Help(format)) if err != nil { return err } diff --git a/cmd/tools_test.go b/cmd/tools_test.go index 0eca88f5..865b582c 100644 --- a/cmd/tools_test.go +++ b/cmd/tools_test.go @@ -36,8 +36,8 @@ func TestPub(t *testing.T) { // create the basic configuration serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", - "--config-file", serverconf) + _, err := ExecuteCmd(createServerConfigCmd(), []string{"--mem-resolver", + "--config-file", serverconf}...) require.NoError(t, err) // start a server with the config at a random port @@ -45,8 +45,7 @@ func TestPub(t *testing.T) { // with the captured ports, regenerate the operator jwt // we only need the client to update - _, _, err = ExecuteCmd(createEditOperatorCmd(), - "--service-url", strings.Join(ports.Nats, ",")) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--service-url", strings.Join(ports.Nats, ",")}...) require.NoError(t, err) // create a conn to the server @@ -65,7 +64,7 @@ func TestPub(t *testing.T) { require.NoError(t, nc.Flush()) // pub a message - _, _, err = ExecuteCmd(createPubCmd(), v, v) + _, err = ExecuteCmd(createPubCmd(), []string{v, v}...) require.NoError(t, err) control := <-c @@ -83,13 +82,13 @@ func TestPubPermissionViolation(t *testing.T) { v := nuid.Next() ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createEditUserCmd(), "--deny-pub", v) + _, err := ExecuteCmd(createEditUserCmd(), []string{"--deny-pub", v}...) require.NoError(t, err) // create the basic configuration serverconf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--mem-resolver", - "--config-file", serverconf) + _, err = ExecuteCmd(createServerConfigCmd(), []string{"--mem-resolver", + "--config-file", serverconf}...) require.NoError(t, err) // start a server with the config at a random port @@ -97,8 +96,7 @@ func TestPubPermissionViolation(t *testing.T) { // with the captured ports, regenerate the operator jwt // we only need the client to update - _, _, err = ExecuteCmd(createEditOperatorCmd(), - "--service-url", strings.Join(ports.Nats, ",")) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--service-url", strings.Join(ports.Nats, ",")}...) require.NoError(t, err) // create a conn to the server @@ -108,7 +106,7 @@ func TestPubPermissionViolation(t *testing.T) { defer nc.Close() // pub a message - _, _, err = ExecuteCmd(createPubCmd(), v, v) + _, err = ExecuteCmd(createPubCmd(), []string{v, v}...) require.Error(t, err) require.Contains(t, err.Error(), "Permissions Violation") } @@ -121,7 +119,7 @@ func TestSub(t *testing.T) { // create the basic configuration conf := filepath.Join(ts.Dir, "server.conf") - _, _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", + _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", "--config-file", conf) require.NoError(t, err) @@ -129,7 +127,7 @@ func TestSub(t *testing.T) { ports := ts.RunServerWithConfig(t, conf) // with the captured ports, regenerate the operator jwt - we only need the client to update - _, _, err = ExecuteCmd(createEditOperatorCmd(), + _, err = ExecuteCmd(createEditOperatorCmd(), "--service-url", strings.Join(ports.Nats, ",")) require.NoError(t, err) @@ -139,14 +137,13 @@ func TestSub(t *testing.T) { log.SetFlags(log.LstdFlags) // subscribe a message type po struct { - stdout string - stderr string - err error + CmdOutput + err error } c := make(chan po) go func() { var r po - r.stdout, r.stderr, r.err = ExecuteCmd(createSubCmd(), "--max-messages", "1", v) + r.CmdOutput, r.err = ExecuteCmd(createSubCmd(), "--max-messages", "1", v) c <- r }() @@ -163,11 +160,8 @@ func TestSub(t *testing.T) { select { case r := <-c: - t.Log(r.stdout) - t.Log(r.stderr) - t.Log(r.err) require.NoError(t, r.err) - require.Contains(t, r.stderr, fmt.Sprintf("received on [%s]: '%s'", v, v)) + require.Contains(t, r.Out, fmt.Sprintf("received on [%s]: '%s'", v, v)) case <-time.After(25 * time.Second): t.Fatal("timed out") } @@ -182,26 +176,25 @@ func TestSubPermissionViolation(t *testing.T) { v := nuid.Next() ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createEditUserCmd(), "--deny-sub", v) + _, err := ExecuteCmd(createEditUserCmd(), []string{"--deny-sub", v}...) require.NoError(t, err) // create the basic configuration conf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--mem-resolver", - "--config-file", conf) + _, err = ExecuteCmd(createServerConfigCmd(), []string{"--mem-resolver", + "--config-file", conf}...) require.NoError(t, err) // start a server with the config at a random port ports := ts.RunServerWithConfig(t, conf) // with the captured ports, regenerate the operator jwt - we only need the client to update - _, _, err = ExecuteCmd(createEditOperatorCmd(), - "--service-url", strings.Join(ports.Nats, ",")) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--service-url", strings.Join(ports.Nats, ",")}...) require.NoError(t, err) log.SetFlags(log.LstdFlags) - _, _, err = ExecuteCmd(createSubCmd(), "--max-messages", "1", v) + _, err = ExecuteCmd(createSubCmd(), []string{"--max-messages", "1", v}...) require.Error(t, err) require.Contains(t, err.Error(), "Permissions Violation") } @@ -215,7 +208,7 @@ func TestReq(t *testing.T) { // create the basic configuration conf := filepath.Join(ts.Dir, "server.conf") - _, _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", + _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", "--config-file", conf) require.NoError(t, err) @@ -223,7 +216,7 @@ func TestReq(t *testing.T) { ports := ts.RunServerWithConfig(t, conf) // with the captured ports, regenerate the operator jwt - we only need the client to update - _, _, err = ExecuteCmd(createEditOperatorCmd(), + _, err = ExecuteCmd(createEditOperatorCmd(), "--service-url", strings.Join(ports.Nats, ",")) require.NoError(t, err) @@ -243,9 +236,9 @@ func TestReq(t *testing.T) { require.NoError(t, sub.AutoUnsubscribe(1)) require.NoError(t, nc.Flush()) - _, stderr, err := ExecuteCmd(createToolReqCmd(), v, v) + out, err := ExecuteCmd(createToolReqCmd(), v, v) require.NoError(t, err) - require.Contains(t, stderr, strings.ToUpper(v)) + require.Contains(t, out.Out, strings.ToUpper(v)) } func TestReply(t *testing.T) { @@ -256,16 +249,15 @@ func TestReply(t *testing.T) { // create the basic configuration conf := filepath.Join(ts.Dir, "server.conf") - _, _, err := ExecuteCmd(createServerConfigCmd(), "--mem-resolver", - "--config-file", conf) + _, err := ExecuteCmd(createServerConfigCmd(), []string{"--mem-resolver", + "--config-file", conf}...) require.NoError(t, err) // start a server with the config at a random port ports := ts.RunServerWithConfig(t, conf) // with the captured ports, regenerate the operator jwt - we only need the client to update - _, _, err = ExecuteCmd(createEditOperatorCmd(), - "--service-url", strings.Join(ports.Nats, ",")) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--service-url", strings.Join(ports.Nats, ",")}...) require.NoError(t, err) // generate a random subject/payload @@ -273,14 +265,13 @@ func TestReply(t *testing.T) { // subscribe a message type po struct { - stdout string - stderr string - err error + CmdOutput + err error } c := make(chan po) go func() { var r po - r.stdout, r.stderr, r.err = ExecuteCmd(createReplyCmd(), "--max-messages", "1", v) + r.CmdOutput, r.err = ExecuteCmd(createReplyCmd(), []string{"--max-messages", "1", v}...) c <- r }() @@ -306,24 +297,23 @@ func TestReplyPermissionViolation(t *testing.T) { v := nuid.Next() ts.AddUser(t, "A", "U") - _, _, err := ExecuteCmd(createEditUserCmd(), "--deny-sub", v) + _, err := ExecuteCmd(createEditUserCmd(), []string{"--deny-sub", v}...) require.NoError(t, err) // create the basic configuration conf := filepath.Join(ts.Dir, "server.conf") - _, _, err = ExecuteCmd(createServerConfigCmd(), "--mem-resolver", - "--config-file", conf) + _, err = ExecuteCmd(createServerConfigCmd(), []string{"--mem-resolver", + "--config-file", conf}...) require.NoError(t, err) // start a server with the config at a random port ports := ts.RunServerWithConfig(t, conf) // with the captured ports, regenerate the operator jwt - we only need the client to update - _, _, err = ExecuteCmd(createEditOperatorCmd(), - "--service-url", strings.Join(ports.Nats, ",")) + _, err = ExecuteCmd(createEditOperatorCmd(), []string{"--service-url", strings.Join(ports.Nats, ",")}...) require.NoError(t, err) - _, _, err = ExecuteCmd(createReplyCmd(), "--max-messages", "1", v) + _, err = ExecuteCmd(createReplyCmd(), []string{"--max-messages", "1", v}...) require.Error(t, err) require.Contains(t, err.Error(), "Permissions Violation") } diff --git a/cmd/update.go b/cmd/update.go index 2236179e..2b8eb6bd 100644 --- a/cmd/update.go +++ b/cmd/update.go @@ -102,11 +102,9 @@ func createUpdateCommand() *cobra.Command { return err } - cmd.Printf("Successfully updated to version %s\n", nvs.Version.String()) - cmd.Println() - cmd.Println("Release Notes:") - cmd.Println() - cmd.Println(cli.Wrap(80, nvs.ReleaseNotes)) + out := cmd.OutOrStdout() + fmt.Fprintf(out, "Updating to version %s\n\n", nvs.Version.String()) + fmt.Fprintf(out, "Release Notes:\n\n%s\n", cli.Wrap(80, nvs.ReleaseNotes)) return nil }, diff --git a/cmd/update_test.go b/cmd/update_test.go index bd528e7a..9eb86f90 100644 --- a/cmd/update_test.go +++ b/cmd/update_test.go @@ -17,13 +17,12 @@ package cmd import ( "fmt" - "os" - "testing" - "time" - "github.com/blang/semver" "github.com/rhysd/go-github-selfupdate/selfupdate" "github.com/stretchr/testify/require" + "os" + "testing" + "time" ) func TestUpdate_RunDoesntUpdateOrCheck(t *testing.T) { @@ -112,7 +111,7 @@ func TestUpdate_DoUpdateWithV(t *testing.T) { var updateCalled bool updateCheckFn = func(slug string, wantVer string) (*selfupdate.Release, bool, error) { if wantVer != "" && !semver.MustParse(wantVer).EQ(semver.MustParse("1.0.0")) { - return nil, false, fmt.Errorf("Expected request from 1.0.0 but got %s", wantVer) + return nil, false, fmt.Errorf("expected request from 1.0.0 but got %s", wantVer) } checkCalled = true return &selfupdate.Release{Version: semver.MustParse("1.0.1"), ReleaseNotes: "f33dfac3"}, true, nil @@ -127,11 +126,11 @@ func TestUpdate_DoUpdateWithV(t *testing.T) { updateFn = nil }() - _, stderr, err := ExecuteCmd(createUpdateCommand()) + out, err := ExecuteCmd(createUpdateCommand()) require.NoError(t, err) require.True(t, checkCalled) require.True(t, updateCalled) - require.Contains(t, stderr, "f33dfac3") + require.Contains(t, out.Out, "f33dfac3") } func TestUpdate_DoUpdate(t *testing.T) { @@ -146,7 +145,7 @@ func TestUpdate_DoUpdate(t *testing.T) { var updateCalled bool updateCheckFn = func(slug string, wantVer string) (*selfupdate.Release, bool, error) { if wantVer != "" && !semver.MustParse(wantVer).EQ(semver.MustParse("1.0.0")) { - return nil, false, fmt.Errorf("Expected request from 1.0.0 but got %s", wantVer) + return nil, false, fmt.Errorf("expected request from 1.0.0 but got %s", wantVer) } checkCalled = true return &selfupdate.Release{Version: semver.MustParse("1.0.1"), ReleaseNotes: "f33dfac3"}, true, nil @@ -161,11 +160,11 @@ func TestUpdate_DoUpdate(t *testing.T) { updateFn = nil }() - _, stderr, err := ExecuteCmd(createUpdateCommand()) + out, err := ExecuteCmd(createUpdateCommand()) require.NoError(t, err) require.True(t, checkCalled) require.True(t, updateCalled) - require.Contains(t, stderr, "f33dfac3") + require.Contains(t, out.Out, "f33dfac3") } func TestUpdate_VerPresent(t *testing.T) { @@ -180,7 +179,7 @@ func TestUpdate_VerPresent(t *testing.T) { var updateCalled bool updateCheckFn = func(slug string, wantVer string) (*selfupdate.Release, bool, error) { if !semver.MustParse(wantVer).EQ(semver.MustParse("2.0.0")) { - return nil, false, fmt.Errorf("Expected request from 2.0.0 but got %s", wantVer) + return nil, false, fmt.Errorf("expected request from 2.0.0 but got %s", wantVer) } checkCalled = true return &selfupdate.Release{Version: semver.MustParse("2.0.0"), ReleaseNotes: "f33dfac3"}, true, nil @@ -195,11 +194,11 @@ func TestUpdate_VerPresent(t *testing.T) { updateFn = nil }() - _, stderr, err := ExecuteCmd(createUpdateCommand(), "--version", "2.0.0") + out, err := ExecuteCmd(createUpdateCommand(), "--version", "2.0.0") require.NoError(t, err) require.True(t, checkCalled) require.True(t, updateCalled) - require.Contains(t, stderr, "f33dfac3") + require.Contains(t, out.Out, "f33dfac3") } func TestUpdate_VerSame(t *testing.T) { @@ -229,7 +228,7 @@ func TestUpdate_VerSame(t *testing.T) { updateFn = nil }() - _, _, err := ExecuteCmd(createUpdateCommand(), "--version", "1.0.0") + _, err := ExecuteCmd(createUpdateCommand(), []string{"--version", "1.0.0"}...) require.NoError(t, err) require.True(t, checkCalled) require.False(t, updateCalled) @@ -262,9 +261,9 @@ func TestUpdate_VerNotFound(t *testing.T) { updateFn = nil }() - _, stderr, err := ExecuteCmd(createUpdateCommand(), "--version", "2.0.0") + out, err := ExecuteCmd(createUpdateCommand(), []string{"--version", "2.0.0"}...) require.Error(t, err) require.True(t, checkCalled) require.False(t, updateCalled) - require.Contains(t, stderr, "version 2.0.0 not found") + require.Contains(t, out.Err, "version 2.0.0 not found") } diff --git a/cmd/upgradejwt_test.go b/cmd/upgradejwt_test.go index ca57153e..605fec00 100644 --- a/cmd/upgradejwt_test.go +++ b/cmd/upgradejwt_test.go @@ -19,14 +19,13 @@ import ( "archive/zip" "encoding/json" "fmt" - "os" - "path/filepath" - "testing" - "github.com/nats-io/jwt/v2" jwtv1 "github.com/nats-io/jwt/v2/v1compat" "github.com/nats-io/nkeys" "github.com/stretchr/testify/require" + "os" + "path/filepath" + "testing" "github.com/nats-io/nsc/v2/cmd/store" ) @@ -71,7 +70,7 @@ func checkJwtVersion(t *testing.T, ts *TestStore, opName string, version int, to func executeFailingCmd(t *testing.T, args ...string) { t.Helper() - _, _, err := ExecuteCmd(rootCmd, args...) // could be any command + _, err := ExecuteCmd(rootCmd, args...) // could be any command require.Error(t, err) require.Contains(t, err.Error(), "This version of nsc only supports jwtV2") require.Contains(t, err.Error(), "upgrade-jwt") @@ -79,7 +78,7 @@ func executeFailingCmd(t *testing.T, args ...string) { func executePassingCmd(t *testing.T, args ...string) { t.Helper() - _, _, err := ExecuteCmd(rootCmd, args...) // could be any command + _, err := ExecuteCmd(rootCmd, args...) // could be any command require.NoError(t, err) } @@ -121,12 +120,12 @@ func TestUpgradeNonManaged(t *testing.T) { executeFailingCmd(t, "edit", "operator", "--tag", "foo") // try writing operator executePassingCmd(t, "env") // only few exceptions - stdout, stderr, err := ExecuteInteractiveCmd(rootCmd, []interface{}{false, false}, "upgrade-jwt") // only works in interactive mode - t.Log(stdout) - t.Log(stderr) + out, err := ExecuteInteractiveCmd(rootCmd, []interface{}{false, false}, "upgrade-jwt") // only works in interactive mode + t.Log(out.Out) + t.Log(out.Err) require.NoError(t, err) checkJwtVersion(t, ts, "O", 1, token) - _, _, err = ExecuteInteractiveCmd(rootCmd, []interface{}{false, true}, "upgrade-jwt") + _, err = ExecuteInteractiveCmd(rootCmd, []interface{}{false, true}, "upgrade-jwt") require.NoError(t, err) checkJwtVersion(t, ts, "O", 2, "") @@ -149,13 +148,13 @@ func TestUpgradeNoKeyNonManaged(t *testing.T) { executeFailingCmd(t, "edit", "operator", "--tag", "foo") // try writing operator executePassingCmd(t, "env") // only few exceptions - _, stdErr, err := ExecuteInteractiveCmd(rootCmd, []interface{}{}, "upgrade-jwt") // only works in interactive mode + stdErr, err := ExecuteInteractiveCmd(rootCmd, []interface{}{}, []string{"upgrade-jwt"}...) // only works in interactive mode require.NoError(t, err) - require.Contains(t, stdErr, "Identity Key for Operator") - require.Contains(t, stdErr, "you need to restore it for this command to work") + require.Contains(t, stdErr.Out, "Identity Key for Operator") + require.Contains(t, stdErr.Out, "you need to restore it for this command to work") checkJwtVersion(t, ts, "O", 1, token) storeOperatorKey(t, ts, kp) - _, _, err = ExecuteInteractiveCmd(rootCmd, []interface{}{false, true}, "upgrade-jwt") + _, err = ExecuteInteractiveCmd(rootCmd, []interface{}{false, true}, []string{"upgrade-jwt"}...) require.NoError(t, err) checkJwtVersion(t, ts, "O", 2, "") @@ -174,10 +173,10 @@ func TestUpgradeManaged(t *testing.T) { executeFailingCmd(t, "list", "keys") // could be any command executePassingCmd(t, "env") // only few exceptions - _, stdErr, err := ExecuteInteractiveCmd(rootCmd, []interface{}{false}, "upgrade-jwt") // only works in interactive mode + out, err := ExecuteInteractiveCmd(rootCmd, []interface{}{false}, []string{"upgrade-jwt"}...) // only works in interactive mode require.NoError(t, err) - require.Contains(t, stdErr, "Your store is in managed mode") - require.Contains(t, stdErr, "nsc add operator --force --url") + require.Contains(t, out.Out, "Your store is in managed mode") + require.Contains(t, out.Out, "nsc add operator --force --url") checkJwtVersion(t, ts, "O", 1, tokenV1) // assert nothing was changed executePassingCmd(t, "add", "operator", "--force", "--url", tfV2) @@ -194,7 +193,7 @@ func TestUpgradeBackup(t *testing.T) { makeNonManaged(t, ts, "O", kp) checkJwtVersion(t, ts, "O", 1, token) backup := filepath.Join(ts.Dir, "test.zip") - _, _, err := ExecuteInteractiveCmd(rootCmd, []interface{}{true, backup, false}, "upgrade-jwt") // only works in interactive mode + _, err := ExecuteInteractiveCmd(rootCmd, []interface{}{true, backup, false}, "upgrade-jwt") // only works in interactive mode require.NoError(t, err) closer, err := zip.OpenReader(backup) require.NoError(t, err) diff --git a/cmd/util_test.go b/cmd/util_test.go index 43c10906..defc4fe1 100644 --- a/cmd/util_test.go +++ b/cmd/util_test.go @@ -37,7 +37,7 @@ import ( "github.com/nats-io/jwt/v2" jwt1 "github.com/nats-io/jwt/v2/v1compat" "github.com/nats-io/nats-server/v2/server" - nats "github.com/nats-io/nats.go" + "github.com/nats-io/nats.go" "github.com/nats-io/nkeys" "github.com/stretchr/testify/require" @@ -284,7 +284,7 @@ func (ts *TestStore) GetStoresRoot() string { func (ts *TestStore) AddAccount(t *testing.T, accountName string) { if !ts.Store.Has(store.Accounts, accountName, store.JwtName(accountName)) { - _, _, err := ExecuteCmd(CreateAddAccountCmd(), "--name", accountName) + _, err := ExecuteCmd(CreateAddAccountCmd(), []string{"--name", accountName}...) require.NoError(t, err) } } @@ -293,14 +293,14 @@ func (ts *TestStore) AddAccountWithSigner(t *testing.T, accountName string, sk n if !ts.Store.Has(store.Accounts, accountName, store.JwtName(accountName)) { seed, err := sk.Seed() require.NoError(t, err) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddAccountCmd()), "--name", accountName, "-K", string(seed)) + _, err = ExecuteCmd(HoistRootFlags(CreateAddAccountCmd()), []string{"--name", accountName, "-K", string(seed)}...) require.NoError(t, err) } } func (ts *TestStore) AddUser(t *testing.T, accountName string, userName string) { ts.AddAccount(t, accountName) - _, _, err := ExecuteCmd(CreateAddUserCmd(), "--account", accountName, "--name", userName) + _, err := ExecuteCmd(CreateAddUserCmd(), []string{"--account", accountName, "--name", userName}...) require.NoError(t, err) } @@ -308,7 +308,7 @@ func (ts *TestStore) AddUserWithSigner(t *testing.T, accountName string, userNam ts.AddAccount(t, accountName) seed, err := sk.Seed() require.NoError(t, err) - _, _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), "--account", accountName, "--name", userName, "-K", string(seed)) + _, err = ExecuteCmd(HoistRootFlags(CreateAddUserCmd()), []string{"--account", accountName, "--name", userName, "-K", string(seed)}...) require.NoError(t, err) } @@ -325,7 +325,7 @@ func (ts *TestStore) AddExport(t *testing.T, accountName string, kind jwt.Export } ts.AddAccount(t, accountName) - _, _, err := ExecuteCmd(createAddExportCmd(), flags...) + _, err := ExecuteCmd(createAddExportCmd(), flags...) require.NoError(t, err) } @@ -357,7 +357,7 @@ func (ts *TestStore) AddImport(t *testing.T, srcAccount string, kind jwt.ExportT } else { flags = append(flags, "--src-account", srcAccount, "--remote-subject", subject) } - _, _, err := ExecuteCmd(createAddImportCmd(), flags...) + _, err := ExecuteCmd(createAddImportCmd(), flags...) require.NoError(t, err) } @@ -372,9 +372,9 @@ func (ts *TestStore) GenerateActivation(t *testing.T, srcAccount string, subject } flags := []string{"--account", srcAccount, "--target-account", tpub, "--subject", subject} - stdout, _, err := ExecuteCmd(createGenerateActivationCmd(), flags...) + out, err := ExecuteCmd(createGenerateActivationCmd(), flags...) require.NoError(t, err) - token, err := jwt.ParseDecoratedJWT([]byte(stdout)) + token, err := jwt.ParseDecoratedJWT([]byte(out.Out)) require.NoError(t, err) return token } @@ -385,9 +385,9 @@ func (ts *TestStore) GenerateActivationWithSigner(t *testing.T, srcAccount strin require.NoError(t, err) flags := []string{"--account", srcAccount, "--target-account", tpub, "--subject", subject, "-K", string(seed)} - stdout, _, err := ExecuteCmd(HoistRootFlags(createGenerateActivationCmd()), flags...) + out, err := ExecuteCmd(HoistRootFlags(createGenerateActivationCmd()), flags...) require.NoError(t, err) - token, err := jwt.ParseDecoratedJWT([]byte(stdout)) + token, err := jwt.ParseDecoratedJWT([]byte(out.Out)) require.NoError(t, err) return token } diff --git a/cmd/validate_test.go b/cmd/validate_test.go index 99d93b47..5d02ddf5 100644 --- a/cmd/validate_test.go +++ b/cmd/validate_test.go @@ -16,14 +16,13 @@ package cmd import ( + "github.com/nats-io/jwt/v2" + "github.com/nats-io/nsc/v2/cmd/store" + "github.com/stretchr/testify/require" "os" "path/filepath" "strings" "testing" - - "github.com/nats-io/jwt/v2" - "github.com/nats-io/nsc/v2/cmd/store" - "github.com/stretchr/testify/require" ) func Test_ValidateNoOperator(t *testing.T) { @@ -31,7 +30,7 @@ func Test_ValidateNoOperator(t *testing.T) { defer ts.Done(t) storeDir := ts.AddSubDir(t, "stores") require.DirExists(t, storeDir) - _, _, err := ExecuteCmd(createValidateCommand()) + _, err := ExecuteCmd(createValidateCommand(), []string{}...) require.Error(t, err) t.Log(err.Error()) require.True(t, strings.Contains(err.Error(), "set an operator") || @@ -42,10 +41,10 @@ func Test_ValidateNoAccount(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) - _, stderr, err := ExecuteCmd(createValidateCommand()) + out, err := ExecuteCmd(createValidateCommand()) require.NoError(t, err) - require.Contains(t, stderr, "Operator \"O\"") - require.Contains(t, stderr, "No issues found") + require.Contains(t, out.Out, "Operator \"O\"") + require.Contains(t, out.Out, "No issues found") } func Test_ValidateExpiredOperator(t *testing.T) { @@ -62,9 +61,9 @@ func Test_ValidateExpiredOperator(t *testing.T) { require.NoError(t, err) require.NoError(t, ts.Store.StoreRaw([]byte(token))) - _, stderr, err := ExecuteCmd(createValidateCommand()) + out, err := ExecuteCmd(createValidateCommand()) require.Error(t, err) - require.Contains(t, stderr, "claim is expired") + require.Contains(t, out.Out, "claim is expired") } func Test_ValidateBadOperatorIssuer(t *testing.T) { @@ -78,9 +77,9 @@ func Test_ValidateBadOperatorIssuer(t *testing.T) { require.NoError(t, err) require.NoError(t, ts.Store.StoreRaw([]byte(token))) - _, stderr, err := ExecuteCmd(createValidateCommand()) + out, err := ExecuteCmd(createValidateCommand()) require.Error(t, err) - require.Contains(t, stderr, "not issued by operator") + require.Contains(t, out.Out, "not issued by operator") } func Test_ExpiredAccount(t *testing.T) { @@ -100,9 +99,9 @@ func Test_ExpiredAccount(t *testing.T) { require.NoError(t, err) require.Nil(t, rs) - _, stderr, err := ExecuteCmd(createValidateCommand()) + out, err := ExecuteCmd(createValidateCommand()) require.Error(t, err) - require.Contains(t, stderr, "claim is expired") + require.Contains(t, out.Out, "claim is expired") } func Test_ValidateBadAccountIssuer(t *testing.T) { @@ -120,9 +119,9 @@ func Test_ValidateBadAccountIssuer(t *testing.T) { require.NoError(t, err) require.Nil(t, rs) - _, stderr, err := ExecuteCmd(createValidateCommand()) + out, err := ExecuteCmd(createValidateCommand()) require.Error(t, err) - require.Contains(t, stderr, "not issued by operator") + require.Contains(t, out.Out, "not issued by operator") } func Test_ValidateBadUserIssuer(t *testing.T) { @@ -139,11 +138,11 @@ func Test_ValidateBadUserIssuer(t *testing.T) { require.NoError(t, err) fp := filepath.Join(ts.StoreDir, "O", store.Accounts, "A", store.Users, store.JwtName("U")) require.NoError(t, os.Remove(fp)) - require.NoError(t, Write(fp, []byte(token))) + require.NoError(t, WriteFile(fp, []byte(token))) - _, stderr, err := ExecuteCmd(createValidateCommand()) + out, err := ExecuteCmd(createValidateCommand()) require.Error(t, err) - require.Contains(t, stderr, "not issued by account") + require.Contains(t, out.Out, "not issued by account") } func Test_ValidateExpiredUser(t *testing.T) { @@ -164,9 +163,9 @@ func Test_ValidateExpiredUser(t *testing.T) { require.NoError(t, err) require.Nil(t, rs) - _, stderr, err := ExecuteCmd(createValidateCommand()) + out, err := ExecuteCmd(createValidateCommand()) require.Error(t, err) - require.Contains(t, stderr, "user \"U\": claim is expired") + require.Contains(t, out.Out, "user \"U\": claim is expired") } func Test_ValidateOneOfAccountOrAll(t *testing.T) { @@ -175,9 +174,9 @@ func Test_ValidateOneOfAccountOrAll(t *testing.T) { ts.AddAccount(t, "A") - _, stderr, err := ExecuteCmd(createValidateCommand(), "--account", "A", "--all-accounts") + out, err := ExecuteCmd(createValidateCommand(), []string{"--account", "A", "--all-accounts"}...) require.Error(t, err) - require.Contains(t, stderr, "specify only one") + require.Contains(t, out.Err, "specify only one") } func Test_ValidateBadAccountName(t *testing.T) { @@ -186,9 +185,9 @@ func Test_ValidateBadAccountName(t *testing.T) { ts.AddAccount(t, "A") - _, stderr, err := ExecuteCmd(createValidateCommand(), "--account", "B") + out, err := ExecuteCmd(createValidateCommand(), []string{"--account", "B"}...) require.Error(t, err) - require.Contains(t, stderr, "not in accounts for operator") + require.Contains(t, out.Err, "not in accounts for operator") } func Test_ValidateInteractive(t *testing.T) { @@ -198,16 +197,16 @@ func Test_ValidateInteractive(t *testing.T) { ts.AddAccount(t, "A") ts.AddAccount(t, "B") - _, stderr, err := ExecuteInteractiveCmd(HoistRootFlags(createValidateCommand()), []interface{}{1}, "--account", "B") + out, err := ExecuteInteractiveCmd(HoistRootFlags(createValidateCommand()), []interface{}{1}, []string{"--account", "B"}...) require.NoError(t, err) - require.Contains(t, stderr, "Account \"B\"") + require.Contains(t, out.Out, "Account \"B\"") } func Test_ValidateJsSys(t *testing.T) { ts := NewTestStore(t, "O") defer ts.Done(t) ts.AddAccount(t, "SYS") - _, _, err := ExecuteCmd(createEditOperatorCmd(), "--system-account", "SYS") + _, err := ExecuteCmd(createEditOperatorCmd(), "--system-account", "SYS") require.NoError(t, err) sys, err := ts.Store.ReadAccountClaim("SYS") @@ -223,7 +222,7 @@ func Test_ValidateJsSys(t *testing.T) { require.NoError(t, err) require.NoError(t, ts.Store.StoreRaw([]byte(token))) - _, stderr, err := ExecuteInteractiveCmd(HoistRootFlags(createValidateCommand()), []interface{}{1}) + out, err := ExecuteInteractiveCmd(HoistRootFlags(createValidateCommand()), []interface{}{1}, []string{}...) require.Error(t, err) - require.Contains(t, stderr, "JetStream should not be enabled for system account") + require.Contains(t, out.Out, "JetStream should not be enabled for system account") } diff --git a/go.mod b/go.mod index ff42d70f..5dd0bf5f 100644 --- a/go.mod +++ b/go.mod @@ -9,17 +9,17 @@ require ( github.com/briandowns/spinner v1.23.1 github.com/dustin/go-humanize v1.0.1 github.com/mitchellh/go-homedir v1.1.0 - github.com/nats-io/cliprompts/v2 v2.0.0-20231014115920-801ca035562a + github.com/nats-io/cliprompts/v2 v2.0.0 github.com/nats-io/jsm.go v0.1.2 github.com/nats-io/jwt/v2 v2.7.3 - github.com/nats-io/nats-server/v2 v2.10.18 + github.com/nats-io/nats-server/v2 v2.10.24 github.com/nats-io/nats.go v1.38.0 github.com/nats-io/nkeys v0.4.9 github.com/nats-io/nuid v1.0.1 github.com/rhysd/go-github-selfupdate v1.2.3 github.com/spf13/cobra v1.8.1 github.com/spf13/pflag v1.0.5 - github.com/stretchr/testify v1.9.0 + github.com/stretchr/testify v1.10.0 github.com/xlab/tablewriter v0.0.0-20160610135559-80b567a11ad5 golang.org/x/text v0.21.0 ) @@ -28,6 +28,7 @@ require ( github.com/AlecAivazis/survey/v2 v2.3.7 // indirect github.com/cpuguy83/go-md2man/v2 v2.0.6 // indirect github.com/davecgh/go-spew v1.1.1 // indirect + github.com/expr-lang/expr v1.16.9 // indirect github.com/fatih/color v1.18.0 // indirect github.com/google/go-github/v30 v30.1.0 // indirect github.com/google/go-querystring v1.1.0 // indirect @@ -45,12 +46,13 @@ require ( github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/tcnksm/go-gitconfig v0.1.2 // indirect github.com/ulikunitz/xz v0.5.12 // indirect - golang.org/x/crypto v0.31.0 // indirect - golang.org/x/net v0.33.0 // indirect - golang.org/x/oauth2 v0.24.0 // indirect - golang.org/x/sys v0.28.0 // indirect - golang.org/x/term v0.27.0 // indirect - golang.org/x/time v0.5.0 // indirect + go.uber.org/automaxprocs v1.6.0 // indirect + golang.org/x/crypto v0.32.0 // indirect + golang.org/x/net v0.34.0 // indirect + golang.org/x/oauth2 v0.25.0 // indirect + golang.org/x/sys v0.29.0 // indirect + golang.org/x/term v0.28.0 // indirect + golang.org/x/time v0.9.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 897408f8..491c2887 100644 --- a/go.sum +++ b/go.sum @@ -1,7 +1,5 @@ -github.com/AlecAivazis/survey/v2 v2.0.4/go.mod h1:WYBhg6f0y/fNYUuesWQc0PKbJcEliGcYHB9sNT3Bg74= github.com/AlecAivazis/survey/v2 v2.3.7 h1:6I/u8FvytdGsgonrYsVn2t8t4QiRnh6QSTqkkhIiSjQ= github.com/AlecAivazis/survey/v2 v2.3.7/go.mod h1:xUTIdE4KCOIjsBAE1JYsUPoCqYdZ1reCfTwbto0Fduo= -github.com/Netflix/go-expect v0.0.0-20180615182759-c93bf25de8e8/go.mod h1:oX5x61PbNXchhh0oikYAH+4Pcfw5LKv21+Jnpr6r6Pc= github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2 h1:+vx7roKuyA63nhn5WAunQHLTznkw5W8b1Xc0dNjp83s= github.com/Netflix/go-expect v0.0.0-20220104043353-73e0943537d2/go.mod h1:HBCaDeC1lPdgDeDbhX8XFpy1jqjK0IBG8W5K+xYqA0w= github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= @@ -18,6 +16,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/expr-lang/expr v1.16.9 h1:WUAzmR0JNI9JCiF0/ewwHB1gmcGw5wW7nWt8gc6PpCI= +github.com/expr-lang/expr v1.16.9/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4= github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= @@ -31,7 +31,6 @@ github.com/google/go-github/v30 v30.1.0/go.mod h1:n8jBpHl45a/rlBUtRJMOG4GhNADUQF github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8= github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU= -github.com/hinshun/vt10x v0.0.0-20180616224451-1954e6464174/go.mod h1:DqJ97dSdRW1W22yXSB90986pcOyQ7r45iio1KN2ez1A= github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec h1:qv2VnGeEQHchGaZ/u7lxST/RaJw+cv273q79D81Xbog= github.com/hinshun/vt10x v0.0.0-20220119200601-820417d04eec/go.mod h1:Q48J4R4DvxnHolD5P8pOtXigYlRuPLGl6moFx3ulM68= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= @@ -46,7 +45,6 @@ github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= -github.com/kr/pty v1.1.4/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= @@ -63,17 +61,16 @@ github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD github.com/minio/highwayhash v1.0.3/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ= github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y= github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= -github.com/mitchellh/go-wordwrap v1.0.0/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo= github.com/mitchellh/go-wordwrap v1.0.1 h1:TLuKupo69TCn6TQSyGxwI1EblZZEsQ0vMlAFQflz0v0= github.com/mitchellh/go-wordwrap v1.0.1/go.mod h1:R62XHJLzvMFRBbcrT7m7WgmE1eOyTSsCt+hzestvNj0= -github.com/nats-io/cliprompts/v2 v2.0.0-20231014115920-801ca035562a h1:28qvB6peSHMhs/m/QoI05X7orBYAB47rV7jrBuMYYxo= -github.com/nats-io/cliprompts/v2 v2.0.0-20231014115920-801ca035562a/go.mod h1:oweZn7AeaVJYKlNHfCIhznJVsdySLSng55vfuINE/d0= +github.com/nats-io/cliprompts/v2 v2.0.0 h1:VF/H4h1gNbMTlZAQKvXal6XKIEJR9LWLOfCbOxYSNZs= +github.com/nats-io/cliprompts/v2 v2.0.0/go.mod h1:VShjOrI+i3j0OEP9V7IuqfuEI1ysO/TfNfEX2azbNZg= github.com/nats-io/jsm.go v0.1.2 h1:T4Fq88a03sPAPWYwrOLQ85oanYsC2Bs6517rUiWBMpQ= github.com/nats-io/jsm.go v0.1.2/go.mod h1:tnubE70CAKi5TNfQiq6XHFqWTuSIe1H7X4sDwfq6ZK8= github.com/nats-io/jwt/v2 v2.7.3 h1:6bNPK+FXgBeAqdj4cYQ0F8ViHRbi7woQLq4W29nUAzE= github.com/nats-io/jwt/v2 v2.7.3/go.mod h1:GvkcbHhKquj3pkioy5put1wvPxs78UlZ7D/pY+BgZk4= -github.com/nats-io/nats-server/v2 v2.10.18 h1:tRdZmBuWKVAFYtayqlBB2BuCHNGAQPvoQIXOKwU3WSM= -github.com/nats-io/nats-server/v2 v2.10.18/go.mod h1:97Qyg7YydD8blKlR8yBsUlPlWyZKjA7Bp5cl3MUE9K8= +github.com/nats-io/nats-server/v2 v2.10.24 h1:KcqqQAD0ZZcG4yLxtvSFJY7CYKVYlnlWoAiVZ6i/IY4= +github.com/nats-io/nats-server/v2 v2.10.24/go.mod h1:olvKt8E5ZlnjyqBGbAXtxvSQKsPodISK5Eo/euIta4s= github.com/nats-io/nats.go v1.38.0 h1:A7P+g7Wjp4/NWqDOOP/K6hfhr54DvdDQUznt5JFg9XA= github.com/nats-io/nats.go v1.38.0/go.mod h1:IGUM++TwokGnXPs82/wCuiHS02/aKrdYUQkU8If6yjw= github.com/nats-io/nkeys v0.4.9 h1:qe9Faq2Gxwi6RZnZMXfmGMZkg3afLLOtrU+gDZJ35b0= @@ -95,10 +92,9 @@ github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3k github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/tcnksm/go-gitconfig v0.1.2 h1:iiDhRitByXAEyjgBqsKi9QU4o2TNtv9kPP3RgPgXBPw= github.com/tcnksm/go-gitconfig v0.1.2/go.mod h1:/8EhP4H7oJZdIPyT+/UIsG87kTzrzM4UsLGSItWYCpE= github.com/ulikunitz/xz v0.5.9/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14= @@ -107,12 +103,13 @@ github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0o github.com/xlab/tablewriter v0.0.0-20160610135559-80b567a11ad5 h1:gmD7q6cCJfBbcuobWQe/KzLsd9Cd3amS1Mq5f3uU1qo= github.com/xlab/tablewriter v0.0.0-20160610135559-80b567a11ad5/go.mod h1:fVwOndYN3s5IaGlMucfgxwMhqwcaJtlGejBU6zX6Yxw= github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= +go.uber.org/automaxprocs v1.6.0 h1:O3y2/QNTOdbF+e/dpXNNW7Rx2hZ4sTIPyybbxyNqTUs= +go.uber.org/automaxprocs v1.6.0/go.mod h1:ifeIMSnPZuznNm6jmdzmU3/bfk01Fe2fotchwEFJ8r8= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U= -golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= +golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc= +golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -121,20 +118,18 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I= -golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4= +golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0= +golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= -golang.org/x/oauth2 v0.24.0 h1:KTBBxWqUa0ykRPLtV69rRto9TLXcqYkeswu48x/gvNE= -golang.org/x/oauth2 v0.24.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= +golang.org/x/oauth2 v0.25.0 h1:CY4y7XT9v0cRI9oupztF8AgiIu99L/ksR/Xp/6jrZ70= +golang.org/x/oauth2 v0.25.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190530182044-ad28b68e88f1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -143,13 +138,13 @@ golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.28.0 h1:Fksou7UEQUWlKvIdsqzJmUmCX3cZuD2+P3XyyzwMhlA= -golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU= +golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.27.0 h1:WP60Sv1nlK1T6SupCHbXzSaN0b9wUmsPoRS9b61A23Q= -golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM= +golang.org/x/term v0.28.0 h1:/Ts8HFuMR2E6IP/jlo7QVLZHggjKQbhu/7H0LJFr3Gg= +golang.org/x/term v0.28.0/go.mod h1:Sw/lC2IAUZ92udQNf3WodGtn4k/XoLyZoh8v/8uiwek= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= @@ -157,8 +152,10 @@ golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= -golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= -golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/time v0.8.0 h1:9i3RxcPv3PZnitoVGMPDKZSq1xW1gK1Xy3ArNOGZfEg= +golang.org/x/time v0.8.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY= +golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=