github.com/kbehouse/nsc@v0.0.6/cmd/describeoperator_test.go (about)

     1  /*
     2   * Copyright 2018-2020 The NATS Authors
     3   * Licensed under the Apache License, Version 2.0 (the "License");
     4   * you may not use this file except in compliance with the License.
     5   * You may obtain a copy of the License at
     6   *
     7   * http://www.apache.org/licenses/LICENSE-2.0
     8   *
     9   * Unless required by applicable law or agreed to in writing, software
    10   * distributed under the License is distributed on an "AS IS" BASIS,
    11   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12   * See the License for the specific language governing permissions and
    13   * limitations under the License.
    14   */
    15  
    16  package cmd
    17  
    18  import (
    19  	"encoding/json"
    20  	"fmt"
    21  	"testing"
    22  
    23  	"github.com/nats-io/jwt/v2"
    24  
    25  	"github.com/stretchr/testify/require"
    26  )
    27  
    28  func TestDescribeOperator_Single(t *testing.T) {
    29  	ts := NewTestStore(t, "operator")
    30  	defer ts.Done(t)
    31  
    32  	pub := ts.GetOperatorPublicKey(t)
    33  	stdout, _, err := ExecuteCmd(createDescribeOperatorCmd())
    34  	require.NoError(t, err)
    35  	require.Contains(t, stdout, pub)
    36  	require.Contains(t, stdout, " operator ")
    37  }
    38  
    39  func TestDescribeOperator_Raw(t *testing.T) {
    40  	ts := NewTestStore(t, "operator")
    41  	defer ts.Done(t)
    42  	oldRaw := Raw
    43  	Raw = true
    44  	defer func() {
    45  		Raw = oldRaw
    46  	}()
    47  
    48  	stdout, _, err := ExecuteCmd(createDescribeOperatorCmd())
    49  	require.NoError(t, err)
    50  
    51  	oc, err := jwt.DecodeOperatorClaims(stdout)
    52  	require.NoError(t, err)
    53  
    54  	require.NotNil(t, oc)
    55  	require.Equal(t, "operator", oc.Name)
    56  }
    57  
    58  func TestDescribeOperator_Multiple(t *testing.T) {
    59  	ts := NewTestStore(t, "operator")
    60  	defer ts.Done(t)
    61  
    62  	ts.AddOperator(t, "A")
    63  
    64  	_, _, err := ExecuteCmd(createDescribeOperatorCmd())
    65  	require.NoError(t, err)
    66  }
    67  
    68  func TestDescribeOperator_MultipleWithContext(t *testing.T) {
    69  	ts := NewTestStore(t, "operator")
    70  	defer ts.Done(t)
    71  
    72  	ts.AddOperator(t, "A")
    73  	ts.AddOperator(t, "B")
    74  
    75  	err := GetConfig().SetOperator("B")
    76  	require.NoError(t, err)
    77  
    78  	pub := ts.GetOperatorPublicKey(t)
    79  
    80  	stdout, _, err := ExecuteCmd(createDescribeOperatorCmd())
    81  	require.NoError(t, err)
    82  	require.Contains(t, stdout, pub)
    83  	require.Contains(t, stdout, " B ")
    84  }
    85  
    86  func TestDescribeOperator_MultipleWithFlag(t *testing.T) {
    87  	ts := NewTestStore(t, "operator")
    88  	defer ts.Done(t)
    89  
    90  	ts.AddOperator(t, "A")
    91  	ts.AddOperator(t, "B")
    92  
    93  	pub := ts.GetOperatorPublicKey(t)
    94  
    95  	stdout, _, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "B")
    96  	require.NoError(t, err)
    97  	require.Contains(t, stdout, " B ")
    98  	require.Contains(t, stdout, pub)
    99  }
   100  
   101  func TestDescribeOperator_MultipleWithBadOperator(t *testing.T) {
   102  	ts := NewTestStore(t, "operator")
   103  	defer ts.Done(t)
   104  
   105  	_, _, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "C")
   106  	require.Error(t, err)
   107  }
   108  
   109  func TestDescribeOperator_AccountServerURL(t *testing.T) {
   110  	ts := NewTestStore(t, "O")
   111  	defer ts.Done(t)
   112  
   113  	stdout, _, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "O")
   114  	require.NoError(t, err)
   115  	require.NotContains(t, stdout, "Account JWT Server")
   116  
   117  	u := "https://asu.com:1234"
   118  	oc, err := ts.Store.ReadOperatorClaim()
   119  	require.NoError(t, err)
   120  	require.NotNil(t, oc)
   121  	oc.AccountServerURL = u
   122  	token, err := oc.Encode(ts.OperatorKey)
   123  	require.NoError(t, err)
   124  	err = ts.Store.StoreRaw([]byte(token))
   125  	require.NoError(t, err)
   126  
   127  	stdout, _, err = ExecuteCmd(createDescribeOperatorCmd(), "--name", "O")
   128  	require.NoError(t, err)
   129  	require.Contains(t, stdout, u)
   130  }
   131  
   132  func TestDescribeOperator_OperatorServiceURLs(t *testing.T) {
   133  	ts := NewTestStore(t, "O")
   134  	defer ts.Done(t)
   135  
   136  	stdout, _, err := ExecuteCmd(createDescribeOperatorCmd(), "--name", "O")
   137  	require.NoError(t, err)
   138  	require.NotContains(t, stdout, "Operator Service URLs")
   139  
   140  	urls := []string{"nats://localhost:4222", "tls://localhost:4333"}
   141  	oc, err := ts.Store.ReadOperatorClaim()
   142  	require.NoError(t, err)
   143  	oc.OperatorServiceURLs.Add(urls...)
   144  
   145  	token, err := oc.Encode(ts.OperatorKey)
   146  	require.NoError(t, err)
   147  	_, err = ts.Store.StoreClaim([]byte(token))
   148  	require.NoError(t, err)
   149  
   150  	stdout, _, err = ExecuteCmd(createDescribeOperatorCmd(), "--name", "O")
   151  	require.NoError(t, err)
   152  	require.Contains(t, stdout, "Operator Service URLs")
   153  	require.Contains(t, stdout, "nats://localhost:4222")
   154  	require.Contains(t, stdout, "tls://localhost:4333")
   155  }
   156  
   157  func TestDescribeOperator_Json(t *testing.T) {
   158  	ts := NewTestStore(t, "O")
   159  	defer ts.Done(t)
   160  
   161  	out, _, err := ExecuteCmd(rootCmd, "describe", "operator", "--json")
   162  	require.NoError(t, err)
   163  	m := make(map[string]interface{})
   164  	err = json.Unmarshal([]byte(out), &m)
   165  	require.NoError(t, err)
   166  	oc, err := ts.Store.ReadOperatorClaim()
   167  	require.NoError(t, err)
   168  	require.NotNil(t, oc)
   169  	require.Equal(t, oc.Subject, m["sub"])
   170  }
   171  
   172  func TestDescribeOperator_JsonPath(t *testing.T) {
   173  	ts := NewTestStore(t, "O")
   174  	defer ts.Done(t)
   175  
   176  	out, _, err := ExecuteCmd(rootCmd, "describe", "operator", "--field", "sub")
   177  	require.NoError(t, err)
   178  	oc, err := ts.Store.ReadOperatorClaim()
   179  	require.NoError(t, err)
   180  	require.Equal(t, fmt.Sprintf("\"%s\"\n", oc.Subject), out)
   181  }