internal/cli/remove_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         "fmt"
  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         "github.com/stretchr/testify/assert"
  31         "testing"
  32 )
  33
  34 var removeMocks *RemoveMocks
  35
  36 type RemoveMocks struct {
  37         sdlIface  *mocks.MockSdlApi
  38         ns        string
  39         kps       []string
  40         keys      []string
  41         retList   error
  42         retRemove error
  43 }
  44
  45 func setupRemoveCliMock(ns string, keyPattern, keys []string, retList, retRemove error) {
  46         removeMocks = new(RemoveMocks)
  47         removeMocks.ns = ns
  48         removeMocks.kps = keyPattern
  49         removeMocks.keys = keys
  50         removeMocks.retList = retList
  51         removeMocks.retRemove = retRemove
  52 }
  53
  54 func newMockSdlRemoveApi() cli.ISyncStorage {
  55         removeMocks.sdlIface = new(mocks.MockSdlApi)
  56         if len(removeMocks.kps) == 0 {
  57                 removeMocks.kps = append(removeMocks.kps, "*")
  58         }
  59         for _, kp := range removeMocks.kps {
  60                 removeMocks.sdlIface.On("ListKeys", removeMocks.ns, kp).Return(removeMocks.keys, removeMocks.retList)
  61         }
  62         removeMocks.sdlIface.On("Remove", removeMocks.ns, removeMocks.keys).Return(removeMocks.retRemove).Maybe()
  63         return removeMocks.sdlIface
  64 }
  65
  66 func runRemoveCli() (string, string, error) {
  67         bufStdout := new(bytes.Buffer)
  68         bufStderr := new(bytes.Buffer)
  69         cmd := cli.NewRemoveCmdForTest(newMockSdlRemoveApi)
  70         cmd.SetOut(bufStdout)
  71         cmd.SetErr(bufStderr)
  72         args := []string{removeMocks.ns}
  73         args = append(args, removeMocks.kps...)
  74         cmd.SetArgs(args)
  75         err := cmd.Execute()
  76
  77         return bufStdout.String(), bufStderr.String(), err
  78 }
  79
  80 func TestCliRemoveCanShowHelp(t *testing.T) {
  81         var expOkErr error
  82         expHelp := "remove <namespace> [<key|pattern>... <keyN|patternN>] [flags]"
  83         expFlagErr := fmt.Errorf("unknown flag: --some-unknown-flag")
  84         expArgCntLtErr := fmt.Errorf("requires at least 1 arg(s), only received 0")
  85         tests := []struct {
  86                 args      []string
  87                 expErr    error
  88                 expOutput string
  89         }{
  90                 {args: []string{"-h"}, expErr: expOkErr, expOutput: expHelp},
  91                 {args: []string{"--help"}, expErr: expOkErr, expOutput: expHelp},
  92                 {args: []string{"--some-unknown-flag"}, expErr: expFlagErr, expOutput: expHelp},
  93                 {args: nil, expErr: expArgCntLtErr, expOutput: expHelp},
  94         }
  95
  96         for _, test := range tests {
  97                 buf := new(bytes.Buffer)
  98                 cmd := cli.NewRemoveCmdForTest(newMockSdlRemoveApi)
  99                 cmd.SetOut(buf)
 100                 cmd.SetArgs(test.args)
 101
 102                 err := cmd.Execute()
 103
 104                 stdout := buf.String()
 105                 assert.Equal(t, test.expErr, err)
 106                 assert.Contains(t, stdout, test.expOutput)
 107         }
 108 }
 109
 110 func TestCliRemoveCommandWithOneKeySuccess(t *testing.T) {
 111         setupRemoveCliMock("some-ns", []string{"some-key"}, []string{"some-key"}, nil, nil)
 112
 113         stdout, stderr, err := runRemoveCli()
 114
 115         assert.Nil(t, err)
 116         assert.Equal(t, "", stdout)
 117         assert.Equal(t, "", stderr)
 118         removeMocks.sdlIface.AssertExpectations(t)
 119 }
 120
 121 func TestCliRemoveCommandWithOneKeyPatternSuccess(t *testing.T) {
 122         setupRemoveCliMock("some-ns", []string{"some-key*"}, []string{"some-key-1", "some-key-1", "some-key-3"}, nil, nil)
 123
 124         stdout, stderr, err := runRemoveCli()
 125
 126         assert.Nil(t, err)
 127         assert.Equal(t, "", stdout)
 128         assert.Equal(t, "", stderr)
 129         removeMocks.sdlIface.AssertExpectations(t)
 130 }
 131
 132 func TestCliRemoveCommandWithMultipleKeyPatternsSuccess(t *testing.T) {
 133         setupRemoveCliMock("some-ns", []string{"some-key*", "other-key*"}, []string{"other-key2"}, nil, nil)
 134
 135         stdout, stderr, err := runRemoveCli()
 136
 137         assert.Nil(t, err)
 138         assert.Equal(t, "", stdout)
 139         assert.Equal(t, "", stderr)
 140         removeMocks.sdlIface.AssertExpectations(t)
 141 }
 142
 143 func TestCliRemoveCommandWithOutKeyOrPatternSuccess(t *testing.T) {
 144         setupRemoveCliMock("some-ns", []string{}, []string{"some-key-1", "some-key-1", "some-key-3"}, nil, nil)
 145
 146         stdout, stderr, err := runRemoveCli()
 147
 148         assert.Nil(t, err)
 149         assert.Equal(t, "", stdout)
 150         assert.Equal(t, "", stderr)
 151         removeMocks.sdlIface.AssertExpectations(t)
 152 }
 153
 154 func TestCliRemoveCommandErrorInSdlApiListKeysFailure(t *testing.T) {
 155         expErr := fmt.Errorf("some-error")
 156         setupRemoveCliMock("some-ns", []string{"*"}, []string{"some-key"}, expErr, nil)
 157
 158         _, stderr, err := runRemoveCli()
 159
 160         assert.Equal(t, expErr, err)
 161         assert.Contains(t, stderr, expErr.Error())
 162         removeMocks.sdlIface.AssertExpectations(t)
 163 }
 164
 165 func TestCliRemoveCommandErrorInSdlApiRemoveFailure(t *testing.T) {
 166         expErr := fmt.Errorf("some-error")
 167         setupRemoveCliMock("some-ns", []string{"*"}, []string{"some-key"}, nil, expErr)
 168
 169         _, stderr, err := runRemoveCli()
 170
 171         assert.Equal(t, expErr, err)
 172         assert.Contains(t, stderr, expErr.Error())
 173         removeMocks.sdlIface.AssertExpectations(t)
 174 }