github.com/aavshr/aws-sdk-go@v1.41.3/service/dynamodb/expression/operand_test.go (about)

     1  //go:build go1.7
     2  // +build go1.7
     3  
     4  package expression
     5  
     6  import (
     7  	"reflect"
     8  	"strings"
     9  	"testing"
    10  
    11  	"github.com/aavshr/aws-sdk-go/aws"
    12  	"github.com/aavshr/aws-sdk-go/service/dynamodb"
    13  )
    14  
    15  // opeErrorMode will help with error cases and checking error types
    16  type opeErrorMode string
    17  
    18  const (
    19  	noOperandError opeErrorMode = ""
    20  	// unsetName error will occur if an empty string is passed into NameBuilder
    21  	unsetName = "unset parameter: NameBuilder"
    22  	// invalidName error will occur if a nested name has an empty intermediary
    23  	// attribute name (i.e. foo.bar..baz)
    24  	invalidName = "invalid parameter: NameBuilder"
    25  	// unsetKey error will occur if an empty string is passed into KeyBuilder
    26  	unsetKey = "unset parameter: KeyBuilder"
    27  )
    28  
    29  func TestBuildOperand(t *testing.T) {
    30  	cases := []struct {
    31  		name     string
    32  		input    OperandBuilder
    33  		expected exprNode
    34  		err      opeErrorMode
    35  	}{
    36  		{
    37  			name:  "basic name",
    38  			input: Name("foo"),
    39  			expected: exprNode{
    40  				names:   []string{"foo"},
    41  				fmtExpr: "$n",
    42  			},
    43  		},
    44  		{
    45  			name:  "duplicate name name",
    46  			input: Name("foo.foo"),
    47  			expected: exprNode{
    48  				names:   []string{"foo", "foo"},
    49  				fmtExpr: "$n.$n",
    50  			},
    51  		},
    52  		{
    53  			name:  "basic value",
    54  			input: Value(5),
    55  			expected: exprNode{
    56  				values: []dynamodb.AttributeValue{
    57  					{
    58  						N: aws.String("5"),
    59  					},
    60  				},
    61  				fmtExpr: "$v",
    62  			},
    63  		},
    64  		{
    65  			name:  "dynamodb.AttributeValue as value",
    66  			input: Value(dynamodb.AttributeValue{N: aws.String("5")}),
    67  			expected: exprNode{
    68  				values: []dynamodb.AttributeValue{
    69  					{
    70  						N: aws.String("5"),
    71  					},
    72  				},
    73  				fmtExpr: "$v",
    74  			},
    75  		},
    76  		{
    77  			name:  "*dynamodb.AttributeValue as value",
    78  			input: Value(&dynamodb.AttributeValue{N: aws.String("5")}),
    79  			expected: exprNode{
    80  				values: []dynamodb.AttributeValue{
    81  					{
    82  						N: aws.String("5"),
    83  					},
    84  				},
    85  				fmtExpr: "$v",
    86  			},
    87  		},
    88  		{
    89  			name:  "nested name",
    90  			input: Name("foo.bar"),
    91  			expected: exprNode{
    92  				names:   []string{"foo", "bar"},
    93  				fmtExpr: "$n.$n",
    94  			},
    95  		},
    96  		{
    97  			name:  "nested name with index",
    98  			input: Name("foo.bar[0].baz"),
    99  			expected: exprNode{
   100  				names:   []string{"foo", "bar", "baz"},
   101  				fmtExpr: "$n.$n[0].$n",
   102  			},
   103  		},
   104  		{
   105  			name:  "basic size",
   106  			input: Name("foo").Size(),
   107  			expected: exprNode{
   108  				names:   []string{"foo"},
   109  				fmtExpr: "size ($n)",
   110  			},
   111  		},
   112  		{
   113  			name:  "key",
   114  			input: Key("foo"),
   115  			expected: exprNode{
   116  				names:   []string{"foo"},
   117  				fmtExpr: "$n",
   118  			},
   119  		},
   120  		{
   121  			name:     "unset key error",
   122  			input:    Key(""),
   123  			expected: exprNode{},
   124  			err:      unsetKey,
   125  		},
   126  		{
   127  			name:     "empty name error",
   128  			input:    Name(""),
   129  			expected: exprNode{},
   130  			err:      unsetName,
   131  		},
   132  		{
   133  			name:     "invalid name",
   134  			input:    Name("foo..bar"),
   135  			expected: exprNode{},
   136  			err:      invalidName,
   137  		},
   138  		{
   139  			name:     "invalid index",
   140  			input:    Name("[foo]"),
   141  			expected: exprNode{},
   142  			err:      invalidName,
   143  		},
   144  	}
   145  
   146  	for _, c := range cases {
   147  		t.Run(c.name, func(t *testing.T) {
   148  			operand, err := c.input.BuildOperand()
   149  
   150  			if c.err != noOperandError {
   151  				if err == nil {
   152  					t.Errorf("expect error %q, got no error", c.err)
   153  				} else {
   154  					if e, a := string(c.err), err.Error(); !strings.Contains(a, e) {
   155  						t.Errorf("expect %q error message to be in %q", e, a)
   156  					}
   157  				}
   158  			} else {
   159  				if err != nil {
   160  					t.Errorf("expect no error, got unexpected Error %q", err)
   161  				}
   162  
   163  				if e, a := c.expected, operand.exprNode; !reflect.DeepEqual(a, e) {
   164  					t.Errorf("expect %v, got %v", e, a)
   165  				}
   166  			}
   167  		})
   168  	}
   169  }