Do not allow '*' character in namespace argument

Validate namespace argument in 'sdlcli get keys' -command.
The command gets an unexpected error when namespace argument
contains '*' asterisk character:

  sdlcli get keys '*' ...
  panic: runtime error: index out of range [1] with length 1

Issue-Id: RIC-113
Change-Id: Ie8b292c4c40801bf9fbfe65274f86485c7085865
Signed-off-by: Petri Ovaska <petri.ovaska@nokia.com>

diff --git a/internal/cli/keys.go b/internal/cli/keys.go
index 33dce25..c656542 100644 (file)
--- a/internal/cli/keys.go
+++ b/internal/cli/keys.go
@@ -67,10 +67,13 @@ func newKeysCmd(sdlCb SyncStorageCreateCb) *cobra.Command {
                Args:    cobra.RangeArgs(1, 2),
                RunE: func(cmd *cobra.Command, args []string) error {
                        sdlgoredis.SetDbLogger(&buf)
-                       keysArgs := newKeysArgs(args[0], "*")
+                       keysArgs := NewKeysArgs(args[0], "*")
                        if len(args) > 1 {
                                keysArgs.pattern = args[1]
                        }
+                       if err := keysArgs.Validate(); err != nil {
+                               return err
+                       }
                        keys, err := runListKeys(sdlCb, keysArgs)
                        if err != nil {
                                fmt.Fprintf(os.Stderr, "%s", buf.String())

diff --git a/internal/cli/keys_test.go b/internal/cli/keys_test.go
index bde5c24..d5c1ef0 100644 (file)
--- a/internal/cli/keys_test.go
+++ b/internal/cli/keys_test.go
@@ -138,3 +138,30 @@ func TestKeysCmdFails(t *testing.T) {
        assert.Equal(t, expNokErr, err)
        assert.Contains(t, result, expNokOut)
 }
+
+func TestKeysCmdInvalidNamespaceArgument(t *testing.T) {
+       expNokErrNsAsterisk1 := errors.New("Invalid character (*) in given * namespace argument.")
+       expNokErrNsAsterisk2 := errors.New("Invalid character (*) in given foo* namespace argument.")
+       expHelp := "Usage:\n  keys <namespace> [pattern|default '*'] [flags]"
+       tests := []struct {
+               args   []string
+               expOut string
+               expErr error
+       }{
+               {args: []string{"*"}, expErr: expNokErrNsAsterisk1, expOut: expHelp},
+               {args: []string{"foo*"}, expErr: expNokErrNsAsterisk2, expOut: expHelp},
+       }
+
+       for _, test := range tests {
+               buf := new(bytes.Buffer)
+               cmd := cli.NewKeysCmdForTest(newMockSdlApi)
+               cmd.SetOut(buf)
+               cmd.SetErr(buf)
+               cmd.SetArgs(test.args)
+               err := cmd.Execute()
+               result := buf.String()
+
+               assert.Equal(t, test.expErr, err)
+               assert.Contains(t, result, test.expOut)
+       }
+}

diff --git a/internal/cli/types.go b/internal/cli/types.go
index 6cfe725..4b50964 100644 (file)
--- a/internal/cli/types.go
+++ b/internal/cli/types.go
@@ -22,7 +22,11 @@
 
 package cli
 
-import "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
+import (
+       "fmt"
+       "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/sdlgoredis"
+       "strings"
+)
 
 //iDatabase is an interface towards database backend, for the time being
 //sdlgoredis.DB implements this interface.
@@ -58,14 +62,22 @@ type keysArgs struct {
        pattern string
 }
 
-//newKeysArgs constructs a new keysArgs struct.
-func newKeysArgs(ns string, pattern string) keysArgs {
+//NewKeysArgs constructs a new keysArgs struct.
+func NewKeysArgs(ns string, pattern string) keysArgs {
        return keysArgs{
                ns:      ns,
                pattern: pattern,
        }
 }
 
+//Validate command arguments in keysArgs.
+func (k keysArgs) Validate() error {
+       if strings.Contains(k.ns, "*") {
+               return fmt.Errorf("Invalid character (*) in given %s namespace argument.", k.ns)
+       }
+       return nil
+}
+
 //nsMap is a map having SDL DB cluster address as a key and namespace map of type nsKeyMap as a value
 type nsMap map[string]nsKeyMap
 

diff --git a/internal/cli/types_test.go b/internal/cli/types_test.go
new file mode 100644 (file)
index 0000000..66f936f
--- /dev/null
+++ b/internal/cli/types_test.go
@@ -0,0 +1,61 @@
+/*
+   Copyright (c) 2021 AT&T Intellectual Property.
+   Copyright (c) 2018-2021 Nokia.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+
+/*
+ * This source code is part of the near-RT RIC (RAN Intelligent Controller)
+ * platform project (RICP).
+ */
+
+package cli_test
+
+import (
+       "errors"
+       "gerrit.o-ran-sc.org/r/ric-plt/sdlgo/internal/cli"
+       "github.com/stretchr/testify/assert"
+       "testing"
+)
+
+func TestTypesKeysArgsValidate(t *testing.T) {
+       tests := []struct {
+               ns      string
+               pattern string
+               expErr  error
+       }{
+               {ns: "", pattern: "", expErr: nil},
+               {ns: "a", pattern: "", expErr: nil},
+               {ns: "aa", pattern: "b", expErr: nil},
+               {ns: "", pattern: "b", expErr: nil},
+       }
+       for _, test := range tests {
+               assert.Equal(t, test.expErr, cli.NewKeysArgs(test.ns, test.pattern).Validate())
+       }
+}
+
+func TestTypesKeysArgsValidateNsAsteriskError(t *testing.T) {
+       tests := []struct {
+               ns      string
+               pattern string
+               expErr  error
+       }{
+               {ns: "*", pattern: "", expErr: errors.New("Invalid character (*) in given * namespace argument.")},
+               {ns: "\\*", pattern: "", expErr: errors.New("Invalid character (*) in given \\* namespace argument.")},
+               {ns: "a*", pattern: "", expErr: errors.New("Invalid character (*) in given a* namespace argument.")},
+       }
+       for _, test := range tests {
+               assert.Equal(t, test.expErr, cli.NewKeysArgs(test.ns, test.pattern).Validate())
+       }
+}