internal/cli/namespaces_test.go

   1 /*
   2    Copyright (c) 2021 AT&T Intellectual Property.
   3    Copyright (c) 2018-2021 Nokia.
   4
   5    Licensed under the Apache License, Version 2.0 (the "License");
   6    you may not use this file except in compliance with the License.
   7    You may obtain a copy of the License at
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  11    Unless required by applicable law or agreed to in writing, software
  12    distributed under the License is distributed on an "AS IS" BASIS,
  13    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14    See the License for the specific language governing permissions and
  15    limitations under the License.
  16 */
  17
  18 /*
  19  * This source code is part of the near-RT RIC (RAN Intelligent Controller)
  20  * platform project (RICP).
  21  */
  22
  23 package cli_test
  24
  25 import (
  26         "bytes"
  27         "errors"
  28         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/cli"
  29         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/mocks"
  30         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
  31         "github.com/stretchr/testify/assert"
  32         "testing"
  33 )
  34
  35 var mNs *nsMock
  36
  37 type nsMock struct {
  38         dbIface    *mocks.MockDB
  39         dbKeys     []string
  40         dbState    sdlgoredis.DbState
  41         dbKeysErr  error
  42         dbStateErr error
  43 }
  44
  45 func setupNamespacesCliMock(keys []string, addr string, keysErr, stateErr error) {
  46         mNs = new(nsMock)
  47         mNs.dbKeys = keys
  48         mNs.dbState.MasterDbState.Fields.Role = "Master"
  49         mNs.dbState.MasterDbState.Fields.Ip = addr
  50         if addr != "" {
  51                 mNs.dbState.MasterDbState.Fields.Port = "6379"
  52         }
  53         mNs.dbKeysErr = keysErr
  54         mNs.dbStateErr = stateErr
  55 }
  56
  57 func newNsMockDatabase() *cli.Database {
  58         db := &cli.Database{}
  59         mNs.dbIface = new(mocks.MockDB)
  60         mNs.dbIface.On("Keys", "*").Return(mNs.dbKeys, mNs.dbKeysErr)
  61         mNs.dbIface.On("State").Return(&mNs.dbState, mNs.dbStateErr).Maybe()
  62         db.Instances = append(db.Instances, mNs.dbIface)
  63         return db
  64 }
  65
  66 func TestNamespacesCmdShowHelp(t *testing.T) {
  67         var expOkErr error
  68         expNokErrTooManyArgs := errors.New("accepts 0 arg(s), received 1")
  69         expHelp := "Usage:\n  namespaces [flags]"
  70         tests := []struct {
  71                 args   []string
  72                 expOut string
  73                 expErr error
  74         }{
  75                 {args: []string{"-h"}, expErr: expOkErr, expOut: expHelp},
  76                 {args: []string{"--help"}, expErr: expOkErr, expOut: expHelp},
  77                 {args: []string{"extra-arg"}, expErr: expNokErrTooManyArgs, expOut: expHelp},
  78         }
  79
  80         for _, test := range tests {
  81                 buf := new(bytes.Buffer)
  82                 cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
  83                 cmd.SetOut(buf)
  84                 cmd.SetErr(buf)
  85                 cmd.SetArgs(test.args)
  86                 err := cmd.Execute()
  87                 result := buf.String()
  88
  89                 assert.Equal(t, test.expErr, err)
  90                 assert.Contains(t, result, test.expOut)
  91         }
  92 }
  93
  94 func TestNamespacesCmdSuccess(t *testing.T) {
  95         expOut := "ns1\n" + "ns2\n" + "ns3\n"
  96         buf := new(bytes.Buffer)
  97         setupNamespacesCliMock([]string{
  98                 "{ns1},key1",
  99                 "{ns3},key1",
 100                 "{ns2},key1",
 101                 "{ns1},key2",
 102         }, "1.2.3.4", nil, nil)
 103         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 104         cmd.SetOut(buf)
 105         cmd.SetErr(buf)
 106
 107         err := cmd.Execute()
 108         result := buf.String()
 109
 110         assert.Nil(t, err)
 111         assert.Equal(t, expOut, result)
 112         mNs.dbIface.AssertExpectations(t)
 113 }
 114
 115 func TestNamespacesCmdWithWideFlagSuccess(t *testing.T) {
 116         expOut :=
 117                 "ADDRESS        NAMESPACE   KEYS   \n" +
 118                         "1.2.3.4:6379   ns1         2      \n" +
 119                         "1.2.3.4:6379   ns2         1      \n" +
 120                         "1.2.3.4:6379   ns3         1      \n"
 121         buf := new(bytes.Buffer)
 122         setupNamespacesCliMock([]string{
 123                 "{ns1},key1",
 124                 "{ns3},key1",
 125                 "{ns2},key1",
 126                 "{ns1},key2",
 127         }, "1.2.3.4", nil, nil)
 128         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 129         cmd.SetOut(buf)
 130         cmd.SetErr(buf)
 131         cmd.SetArgs([]string{"--wide"})
 132
 133         err := cmd.Execute()
 134         result := buf.String()
 135
 136         assert.Nil(t, err)
 137         assert.Equal(t, expOut, result)
 138         mNs.dbIface.AssertExpectations(t)
 139 }
 140
 141 func TestNamespacesCmdNoKeysInDbSuccess(t *testing.T) {
 142         expOut := ""
 143         buf := new(bytes.Buffer)
 144         setupNamespacesCliMock([]string{}, "1.2.3.4", nil, nil)
 145         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 146         cmd.SetOut(buf)
 147         cmd.SetErr(buf)
 148
 149         err := cmd.Execute()
 150         result := buf.String()
 151
 152         assert.Nil(t, err)
 153         assert.Equal(t, expOut, result)
 154         mNs.dbIface.AssertExpectations(t)
 155 }
 156
 157 func TestNamespacesCmdWithWideFlagNoKeysInDbSuccess(t *testing.T) {
 158         expOut := "ADDRESS   NAMESPACE   KEYS   \n"
 159         buf := new(bytes.Buffer)
 160         setupNamespacesCliMock([]string{}, "1.2.3.4", nil, nil)
 161         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 162         cmd.SetOut(buf)
 163         cmd.SetErr(buf)
 164         cmd.SetArgs([]string{"-w"})
 165
 166         err := cmd.Execute()
 167         result := buf.String()
 168
 169         assert.Nil(t, err)
 170         assert.Equal(t, expOut, result)
 171         mNs.dbIface.AssertExpectations(t)
 172 }
 173
 174 func TestNamespacesCmdWithWideFlagStandaloneRedisAddressMissingSuccess(t *testing.T) {
 175         expOut :=
 176                 "ADDRESS   NAMESPACE   KEYS   \n" +
 177                         "          ns1         2      \n" +
 178                         "          ns2         1      \n" +
 179                         "          ns3         1      \n"
 180         buf := new(bytes.Buffer)
 181         setupNamespacesCliMock([]string{
 182                 "{ns1},key1",
 183                 "{ns3},key1",
 184                 "{ns2},key1",
 185                 "{ns1},key2",
 186         }, "", nil, nil)
 187         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 188         cmd.SetOut(buf)
 189         cmd.SetErr(buf)
 190         cmd.SetArgs([]string{"--wide"})
 191
 192         err := cmd.Execute()
 193         result := buf.String()
 194
 195         assert.Nil(t, err)
 196         assert.Equal(t, expOut, result)
 197         mNs.dbIface.AssertExpectations(t)
 198 }
 199
 200 func TestNamespacesCmdDbKeysFailure(t *testing.T) {
 201         expNokErr := errors.New("Some error")
 202         expOut := "Error: Some error"
 203
 204         buf := new(bytes.Buffer)
 205         setupNamespacesCliMock(nil, "1.2.3.4", expNokErr, nil)
 206         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 207         cmd.SetOut(buf)
 208         cmd.SetErr(buf)
 209
 210         err := cmd.Execute()
 211         result := buf.String()
 212
 213         assert.Equal(t, expNokErr, err)
 214         assert.Contains(t, result, expOut)
 215         mNs.dbIface.AssertExpectations(t)
 216 }
 217
 218 func TestNamespacesCmdDbStateFailure(t *testing.T) {
 219         expNokErr := errors.New("Some error")
 220         expOut := "Error: Some error"
 221
 222         buf := new(bytes.Buffer)
 223         setupNamespacesCliMock(nil, "1.2.3.4", nil, expNokErr)
 224         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 225         cmd.SetOut(buf)
 226         cmd.SetErr(buf)
 227
 228         err := cmd.Execute()
 229         result := buf.String()
 230
 231         assert.Equal(t, expNokErr, err)
 232         assert.Contains(t, result, expOut)
 233         mNs.dbIface.AssertExpectations(t)
 234 }
 235
 236 func TestNamespacesCmdNsStartMarkerFailure(t *testing.T) {
 237         expNokErr := errors.New("Namespace parsing error, no '{' in key string 'ns2},key1'")
 238         expOut := "Error: Namespace parsing error, no '{' in key string 'ns2},key1'"
 239
 240         buf := new(bytes.Buffer)
 241         setupNamespacesCliMock([]string{
 242                 "{ns1},key1",
 243                 "ns2},key1",
 244                 "{ns1},key2",
 245         }, "1.2.3.4", nil, nil)
 246         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 247         cmd.SetOut(buf)
 248         cmd.SetErr(buf)
 249
 250         err := cmd.Execute()
 251         result := buf.String()
 252
 253         assert.Equal(t, expNokErr, err)
 254         assert.Contains(t, result, expOut)
 255         mNs.dbIface.AssertExpectations(t)
 256 }
 257
 258 func TestNamespacesCmdNsEndMarkerFailure(t *testing.T) {
 259         expNokErr := errors.New("Namespace parsing error, no '}' in key string '{ns2,key1'")
 260         expOut := "Error: Namespace parsing error, no '}' in key string '{ns2,key1'"
 261
 262         buf := new(bytes.Buffer)
 263         setupNamespacesCliMock([]string{
 264                 "{ns1},key1",
 265                 "{ns2,key1",
 266                 "{ns1},key2",
 267         }, "1.2.3.4", nil, nil)
 268         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 269         cmd.SetOut(buf)
 270         cmd.SetErr(buf)
 271
 272         err := cmd.Execute()
 273         result := buf.String()
 274
 275         assert.Equal(t, expNokErr, err)
 276         assert.Contains(t, result, expOut)
 277         mNs.dbIface.AssertExpectations(t)
 278 }