internal/cli/get_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         "github.com/stretchr/testify/assert"
  31         "testing"
  32 )
  33
  34 var getMocks *GetMocks
  35
  36 type GetMocks struct {
  37         sdlIface *mocks.MockSdlApi
  38         ns       string
  39         keys     []string
  40         result   map[string]interface{}
  41         ret      error
  42 }
  43
  44 func setupGetMock(ns string, keys []string, result map[string]interface{}, ret error) {
  45         getMocks = new(GetMocks)
  46         getMocks.ns = ns
  47         getMocks.keys = keys
  48         getMocks.result = result
  49         getMocks.ret = ret
  50 }
  51
  52 func newSdlGetApiMock() cli.ISyncStorage {
  53         getMocks.sdlIface = new(mocks.MockSdlApi)
  54         getMocks.sdlIface.On("Get", getMocks.ns, getMocks.keys).Return(getMocks.result, getMocks.ret)
  55         return getMocks.sdlIface
  56 }
  57
  58 func runGetCmdCli() (string, string, error) {
  59         bufOut := new(bytes.Buffer)
  60         bufErr := new(bytes.Buffer)
  61
  62         cmd := cli.NewGetCmdForTest(newSdlGetApiMock)
  63         cmd.SetOut(bufOut)
  64         cmd.SetErr(bufErr)
  65         args := []string{getMocks.ns}
  66         args = append(args, getMocks.keys...)
  67         cmd.SetArgs(args)
  68         err := cmd.Execute()
  69
  70         return bufOut.String(), bufErr.String(), err
  71 }
  72
  73 func TestGetCmdShowHelp(t *testing.T) {
  74         var expOkErr error
  75         expHelp := "Display one or many resources.\n\nPrints keys and keys data in the given namespace."
  76         expHelpUsage := "Usage:\n  get <namespace> <key> [<key2> <key3>... <keyN>] [flags]"
  77         expArgsErr := errors.New("accepts command or arguments, received 0")
  78         expNokErr := errors.New("unknown flag: --ff")
  79         tests := []struct {
  80                 args   []string
  81                 expErr error
  82                 expOut string
  83         }{
  84                 {args: []string{"-h"}, expErr: expOkErr, expOut: expHelp},
  85                 {args: []string{"--help"}, expErr: expOkErr, expOut: expHelp},
  86                 {args: []string{}, expErr: expArgsErr, expOut: expHelpUsage},
  87                 {args: []string{"--ff"}, expErr: expNokErr, expOut: expHelpUsage},
  88         }
  89
  90         for _, test := range tests {
  91                 buf := new(bytes.Buffer)
  92                 cmd := cli.NewGetCmdForTest(newSdlGetApiMock)
  93                 cmd.SetOut(buf)
  94                 cmd.SetErr(buf)
  95                 cmd.SetArgs(test.args)
  96                 err := cmd.Execute()
  97                 result := buf.String()
  98
  99                 assert.Equal(t, test.expErr, err)
 100                 assert.Contains(t, result, test.expOut)
 101         }
 102 }
 103
 104 func TestGetCmdSuccess(t *testing.T) {
 105
 106         tests := []struct {
 107                 ns     string
 108                 keys   []string
 109                 result map[string]interface{}
 110                 expOut string
 111                 expErr error
 112         }{
 113                 {ns: "testns", keys: []string{"key1"}, result: map[string]interface{}{}, expOut: "", expErr: nil},
 114                 {ns: "testns", keys: []string{"key1"}, result: map[string]interface{}{"key1": "1"}, expOut: "key1:1\n", expErr: nil},
 115                 {ns: "testns", keys: []string{"key1 key2"}, result: map[string]interface{}{"key1": "1", "key2": "2"}, expOut: "key1:1\nkey2:2\n", expErr: nil},
 116                 {ns: "testns", keys: []string{"key1 key3 key2"}, result: map[string]interface{}{"key1": "1", "key3": "3", "key2": "2"}, expOut: "key1:1\nkey2:2\nkey3:3\n", expErr: nil},
 117                 {ns: "testns", keys: []string{"key1 keyDoesNotExist"}, result: map[string]interface{}{"key1": "1"}, expOut: "key1:1\n", expErr: nil},
 118         }
 119         for _, test := range tests {
 120                 setupGetMock(test.ns, test.keys, test.result, test.expErr)
 121                 stdout, stderr, err := runGetCmdCli()
 122
 123                 assert.Nil(t, err)
 124                 assert.Equal(t, test.expOut, stdout)
 125                 assert.Equal(t, "", stderr)
 126                 getMocks.sdlIface.AssertExpectations(t)
 127         }
 128 }
 129
 130 func TestGetCmdFails(t *testing.T) {
 131         expErr := errors.New("Boom!")
 132
 133         setupGetMock("testns", []string{"key1"}, map[string]interface{}{}, expErr)
 134         _, stderr, err := runGetCmdCli()
 135
 136         assert.Equal(t, expErr, err)
 137         assert.Contains(t, stderr, expErr.Error())
 138         getMocks.sdlIface.AssertExpectations(t)
 139 }