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 TestNamespacesCmdWithPerDbFlagSuccess(t *testing.T) {
 116         expOut := "1.2.3.4:6379: ns1\n" + "1.2.3.4:6379: ns2\n" + "1.2.3.4:6379: ns3\n"
 117         buf := new(bytes.Buffer)
 118         setupNamespacesCliMock([]string{
 119                 "{ns1},key1",
 120                 "{ns3},key1",
 121                 "{ns2},key1",
 122                 "{ns1},key2",
 123         }, "1.2.3.4", nil, nil)
 124         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 125         cmd.SetOut(buf)
 126         cmd.SetErr(buf)
 127         cmd.SetArgs([]string{"--group"})
 128
 129         err := cmd.Execute()
 130         result := buf.String()
 131
 132         assert.Nil(t, err)
 133         assert.Equal(t, expOut, result)
 134         mNs.dbIface.AssertExpectations(t)
 135 }
 136
 137 func TestNamespacesCmdNoKeysInDbSuccess(t *testing.T) {
 138         expOut := ""
 139         buf := new(bytes.Buffer)
 140         setupNamespacesCliMock([]string{}, "1.2.3.4", nil, nil)
 141         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 142         cmd.SetOut(buf)
 143         cmd.SetErr(buf)
 144
 145         err := cmd.Execute()
 146         result := buf.String()
 147
 148         assert.Nil(t, err)
 149         assert.Equal(t, expOut, result)
 150         mNs.dbIface.AssertExpectations(t)
 151 }
 152
 153 func TestNamespacesCmdWithPerDbFlagNoKeysInDbSuccess(t *testing.T) {
 154         expOut := ""
 155         buf := new(bytes.Buffer)
 156         setupNamespacesCliMock([]string{}, "1.2.3.4", nil, nil)
 157         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 158         cmd.SetOut(buf)
 159         cmd.SetErr(buf)
 160         cmd.SetArgs([]string{"--group"})
 161
 162         err := cmd.Execute()
 163         result := buf.String()
 164
 165         assert.Nil(t, err)
 166         assert.Equal(t, expOut, result)
 167         mNs.dbIface.AssertExpectations(t)
 168 }
 169
 170 func TestNamespacesCmdWithPerDbFlagStandaloneRedisAddressMissingSuccess(t *testing.T) {
 171         expOut := "ns1\n" + "ns2\n" + "ns3\n"
 172         buf := new(bytes.Buffer)
 173         setupNamespacesCliMock([]string{
 174                 "{ns1},key1",
 175                 "{ns3},key1",
 176                 "{ns2},key1",
 177                 "{ns1},key2",
 178         }, "", nil, nil)
 179         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 180         cmd.SetOut(buf)
 181         cmd.SetErr(buf)
 182         cmd.SetArgs([]string{"--group"})
 183
 184         err := cmd.Execute()
 185         result := buf.String()
 186
 187         assert.Nil(t, err)
 188         assert.Equal(t, expOut, result)
 189         mNs.dbIface.AssertExpectations(t)
 190 }
 191
 192 func TestNamespacesCmdDbKeysFailure(t *testing.T) {
 193         expNokErr := errors.New("Some error")
 194         expOut := "Error: Some error"
 195
 196         buf := new(bytes.Buffer)
 197         setupNamespacesCliMock(nil, "1.2.3.4", expNokErr, nil)
 198         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 199         cmd.SetOut(buf)
 200         cmd.SetErr(buf)
 201
 202         err := cmd.Execute()
 203         result := buf.String()
 204
 205         assert.Equal(t, expNokErr, err)
 206         assert.Contains(t, result, expOut)
 207         mNs.dbIface.AssertExpectations(t)
 208 }
 209
 210 func TestNamespacesCmdDbStateFailure(t *testing.T) {
 211         expNokErr := errors.New("Some error")
 212         expOut := "Error: Some error"
 213
 214         buf := new(bytes.Buffer)
 215         setupNamespacesCliMock(nil, "1.2.3.4", nil, expNokErr)
 216         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 217         cmd.SetOut(buf)
 218         cmd.SetErr(buf)
 219
 220         err := cmd.Execute()
 221         result := buf.String()
 222
 223         assert.Equal(t, expNokErr, err)
 224         assert.Contains(t, result, expOut)
 225         mNs.dbIface.AssertExpectations(t)
 226 }
 227
 228 func TestNamespacesCmdNsStartMarkerFailure(t *testing.T) {
 229         expNokErr := errors.New("Namespace parsing error, no '{' in key string 'ns2},key1'")
 230         expOut := "Error: Namespace parsing error, no '{' in key string 'ns2},key1'"
 231
 232         buf := new(bytes.Buffer)
 233         setupNamespacesCliMock([]string{
 234                 "{ns1},key1",
 235                 "ns2},key1",
 236                 "{ns1},key2",
 237         }, "1.2.3.4", nil, nil)
 238         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 239         cmd.SetOut(buf)
 240         cmd.SetErr(buf)
 241
 242         err := cmd.Execute()
 243         result := buf.String()
 244
 245         assert.Equal(t, expNokErr, err)
 246         assert.Contains(t, result, expOut)
 247         mNs.dbIface.AssertExpectations(t)
 248 }
 249
 250 func TestNamespacesCmdNsEndMarkerFailure(t *testing.T) {
 251         expNokErr := errors.New("Namespace parsing error, no '}' in key string '{ns2,key1'")
 252         expOut := "Error: Namespace parsing error, no '}' in key string '{ns2,key1'"
 253
 254         buf := new(bytes.Buffer)
 255         setupNamespacesCliMock([]string{
 256                 "{ns1},key1",
 257                 "{ns2,key1",
 258                 "{ns1},key2",
 259         }, "1.2.3.4", nil, nil)
 260         cmd := cli.NewNamespacesCmdForTest(newNsMockDatabase)
 261         cmd.SetOut(buf)
 262         cmd.SetErr(buf)
 263
 264         err := cmd.Execute()
 265         result := buf.String()
 266
 267         assert.Equal(t, expNokErr, err)
 268         assert.Contains(t, result, expOut)
 269         mNs.dbIface.AssertExpectations(t)
 270 }