go.temporal.io/server@v1.23.0/common/searchattribute/encode_test.go (about)

     1  // The MIT License
     2  //
     3  // Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
     4  //
     5  // Copyright (c) 2020 Uber Technologies, Inc.
     6  //
     7  // Permission is hereby granted, free of charge, to any person obtaining a copy
     8  // of this software and associated documentation files (the "Software"), to deal
     9  // in the Software without restriction, including without limitation the rights
    10  // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    11  // copies of the Software, and to permit persons to whom the Software is
    12  // furnished to do so, subject to the following conditions:
    13  //
    14  // The above copyright notice and this permission notice shall be included in
    15  // all copies or substantial portions of the Software.
    16  //
    17  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    18  // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    19  // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    20  // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    21  // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    22  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    23  // THE SOFTWARE.
    24  
    25  package searchattribute
    26  
    27  import (
    28  	"testing"
    29  
    30  	"github.com/stretchr/testify/assert"
    31  	enumspb "go.temporal.io/api/enums/v1"
    32  )
    33  
    34  func Test_Encode_Success(t *testing.T) {
    35  	assert := assert.New(t)
    36  
    37  	sa, err := Encode(map[string]interface{}{
    38  		"key1": "val1",
    39  		"key2": 2,
    40  		"key3": true,
    41  		"key4": nil,
    42  		"key5": []string{"val2", "val3"},
    43  		"key6": []string{},
    44  	}, &NameTypeMap{customSearchAttributes: map[string]enumspb.IndexedValueType{
    45  		"key1": enumspb.INDEXED_VALUE_TYPE_TEXT,
    46  		"key2": enumspb.INDEXED_VALUE_TYPE_INT,
    47  		"key3": enumspb.INDEXED_VALUE_TYPE_BOOL,
    48  		"key4": enumspb.INDEXED_VALUE_TYPE_DOUBLE,
    49  		"key5": enumspb.INDEXED_VALUE_TYPE_KEYWORD,
    50  		"key6": enumspb.INDEXED_VALUE_TYPE_KEYWORD,
    51  	}})
    52  
    53  	assert.NoError(err)
    54  	assert.Len(sa.IndexedFields, 6)
    55  	assert.Equal(`"val1"`, string(sa.IndexedFields["key1"].GetData()))
    56  	assert.Equal("Text", string(sa.IndexedFields["key1"].GetMetadata()["type"]))
    57  	assert.Equal("2", string(sa.IndexedFields["key2"].GetData()))
    58  	assert.Equal("Int", string(sa.IndexedFields["key2"].GetMetadata()["type"]))
    59  	assert.Equal("true", string(sa.IndexedFields["key3"].GetData()))
    60  	assert.Equal("Bool", string(sa.IndexedFields["key3"].GetMetadata()["type"]))
    61  	assert.Equal("", string(sa.IndexedFields["key4"].GetData()))
    62  	assert.Equal("Double", string(sa.IndexedFields["key4"].GetMetadata()["type"]))
    63  	assert.Equal("binary/null", string(sa.IndexedFields["key4"].GetMetadata()["encoding"]))
    64  	assert.Equal(`["val2","val3"]`, string(sa.IndexedFields["key5"].GetData()))
    65  	assert.Equal("Keyword", string(sa.IndexedFields["key5"].GetMetadata()["type"]))
    66  	assert.Equal("json/plain", string(sa.IndexedFields["key5"].GetMetadata()["encoding"]))
    67  	assert.Equal("[]", string(sa.IndexedFields["key6"].GetData()))
    68  	assert.Equal("Keyword", string(sa.IndexedFields["key6"].GetMetadata()["type"]))
    69  	assert.Equal("json/plain", string(sa.IndexedFields["key6"].GetMetadata()["encoding"]))
    70  }
    71  func Test_Encode_NilMap(t *testing.T) {
    72  	assert := assert.New(t)
    73  
    74  	sa, err := Encode(map[string]interface{}{
    75  		"key1": "val1",
    76  		"key2": 2,
    77  		"key3": true,
    78  		"key4": nil,
    79  		"key5": []string{"val2", "val3"},
    80  		"key6": []string{},
    81  	}, nil)
    82  
    83  	assert.NoError(err)
    84  	assert.Len(sa.IndexedFields, 6)
    85  	assert.Equal(`"val1"`, string(sa.IndexedFields["key1"].GetData()))
    86  	assert.Equal("2", string(sa.IndexedFields["key2"].GetData()))
    87  	assert.Equal("true", string(sa.IndexedFields["key3"].GetData()))
    88  	assert.Equal("", string(sa.IndexedFields["key4"].GetData()))
    89  	assert.Equal("binary/null", string(sa.IndexedFields["key4"].GetMetadata()["encoding"]))
    90  	assert.Equal(`["val2","val3"]`, string(sa.IndexedFields["key5"].GetData()))
    91  	assert.Equal("json/plain", string(sa.IndexedFields["key5"].GetMetadata()["encoding"]))
    92  	assert.Equal("[]", string(sa.IndexedFields["key6"].GetData()))
    93  	assert.Equal("json/plain", string(sa.IndexedFields["key6"].GetMetadata()["encoding"]))
    94  }
    95  
    96  func Test_Encode_Error(t *testing.T) {
    97  	assert := assert.New(t)
    98  	sa, err := Encode(map[string]interface{}{
    99  		"key1": "val1",
   100  		"key2": 2,
   101  		"key3": true,
   102  	}, &NameTypeMap{customSearchAttributes: map[string]enumspb.IndexedValueType{
   103  		"key1": enumspb.INDEXED_VALUE_TYPE_TEXT,
   104  		"key4": enumspb.INDEXED_VALUE_TYPE_INT,
   105  		"key3": enumspb.INDEXED_VALUE_TYPE_BOOL,
   106  	}})
   107  
   108  	assert.Error(err)
   109  	assert.ErrorIs(err, ErrInvalidName)
   110  	assert.Len(sa.IndexedFields, 3)
   111  	assert.Equal(`"val1"`, string(sa.IndexedFields["key1"].GetData()))
   112  	assert.Equal("Text", string(sa.IndexedFields["key1"].GetMetadata()["type"]))
   113  	assert.Equal("2", string(sa.IndexedFields["key2"].GetData()))
   114  	assert.Equal("true", string(sa.IndexedFields["key3"].GetData()))
   115  	assert.Equal("Bool", string(sa.IndexedFields["key3"].GetMetadata()["type"]))
   116  }
   117  
   118  func Test_Decode_Success(t *testing.T) {
   119  	assert := assert.New(t)
   120  
   121  	typeMap := &NameTypeMap{customSearchAttributes: map[string]enumspb.IndexedValueType{
   122  		"key1": enumspb.INDEXED_VALUE_TYPE_TEXT,
   123  		"key2": enumspb.INDEXED_VALUE_TYPE_INT,
   124  		"key3": enumspb.INDEXED_VALUE_TYPE_BOOL,
   125  		"key4": enumspb.INDEXED_VALUE_TYPE_DOUBLE,
   126  		"key5": enumspb.INDEXED_VALUE_TYPE_KEYWORD,
   127  		"key6": enumspb.INDEXED_VALUE_TYPE_KEYWORD,
   128  	}}
   129  	sa, err := Encode(map[string]interface{}{
   130  		"key1": "val1",
   131  		"key2": 2,
   132  		"key3": true,
   133  		"key4": nil,
   134  		"key5": []string{"val2", "val3"},
   135  		"key6": []string{},
   136  	}, typeMap)
   137  	assert.NoError(err)
   138  
   139  	vals, err := Decode(sa, typeMap, true)
   140  	assert.NoError(err)
   141  	assert.Len(vals, 6)
   142  	assert.Equal("val1", vals["key1"])
   143  	assert.Equal(int64(2), vals["key2"])
   144  	assert.Equal(true, vals["key3"])
   145  	assert.Nil(vals["key4"])
   146  	assert.Equal([]string{"val2", "val3"}, vals["key5"])
   147  	assert.Nil(vals["key6"])
   148  
   149  	delete(sa.IndexedFields["key1"].Metadata, "type")
   150  	delete(sa.IndexedFields["key2"].Metadata, "type")
   151  	delete(sa.IndexedFields["key3"].Metadata, "type")
   152  	delete(sa.IndexedFields["key4"].Metadata, "type")
   153  	delete(sa.IndexedFields["key5"].Metadata, "type")
   154  	delete(sa.IndexedFields["key6"].Metadata, "type")
   155  
   156  	vals, err = Decode(sa, typeMap, true)
   157  	assert.NoError(err)
   158  	assert.Len(vals, 6)
   159  	assert.Equal("val1", vals["key1"])
   160  	assert.Equal(int64(2), vals["key2"])
   161  	assert.Equal(true, vals["key3"])
   162  	assert.Nil(vals["key4"])
   163  	assert.Equal([]string{"val2", "val3"}, vals["key5"])
   164  	assert.Nil(vals["key6"])
   165  }
   166  
   167  func Test_Decode_NilMap(t *testing.T) {
   168  	assert := assert.New(t)
   169  	typeMap := &NameTypeMap{customSearchAttributes: map[string]enumspb.IndexedValueType{
   170  		"key1": enumspb.INDEXED_VALUE_TYPE_TEXT,
   171  		"key2": enumspb.INDEXED_VALUE_TYPE_INT,
   172  		"key3": enumspb.INDEXED_VALUE_TYPE_BOOL,
   173  		"key4": enumspb.INDEXED_VALUE_TYPE_DOUBLE,
   174  		"key5": enumspb.INDEXED_VALUE_TYPE_KEYWORD,
   175  		"key6": enumspb.INDEXED_VALUE_TYPE_KEYWORD,
   176  	}}
   177  	sa, err := Encode(map[string]interface{}{
   178  		"key1": "val1",
   179  		"key2": 2,
   180  		"key3": true,
   181  		"key4": nil,
   182  		"key5": []string{"val2", "val3"},
   183  		"key6": []string{},
   184  	}, typeMap)
   185  	assert.NoError(err)
   186  
   187  	vals, err := Decode(sa, nil, true)
   188  	assert.NoError(err)
   189  	assert.Len(sa.IndexedFields, 6)
   190  	assert.Equal("val1", vals["key1"])
   191  	assert.Equal(int64(2), vals["key2"])
   192  	assert.Equal(true, vals["key3"])
   193  	assert.Nil(vals["key4"])
   194  	assert.Equal([]string{"val2", "val3"}, vals["key5"])
   195  	assert.Nil(vals["key6"])
   196  }
   197  
   198  func Test_Decode_Error(t *testing.T) {
   199  	assert := assert.New(t)
   200  
   201  	typeMap := &NameTypeMap{customSearchAttributes: map[string]enumspb.IndexedValueType{
   202  		"key1": enumspb.INDEXED_VALUE_TYPE_TEXT,
   203  		"key2": enumspb.INDEXED_VALUE_TYPE_INT,
   204  		"key3": enumspb.INDEXED_VALUE_TYPE_BOOL,
   205  	}}
   206  	sa, err := Encode(map[string]interface{}{
   207  		"key1": "val1",
   208  		"key2": 2,
   209  		"key3": true,
   210  	}, typeMap)
   211  	assert.NoError(err)
   212  
   213  	vals, err := Decode(
   214  		sa,
   215  		&NameTypeMap{customSearchAttributes: map[string]enumspb.IndexedValueType{
   216  			"key1": enumspb.INDEXED_VALUE_TYPE_TEXT,
   217  			"key4": enumspb.INDEXED_VALUE_TYPE_INT,
   218  			"key3": enumspb.INDEXED_VALUE_TYPE_BOOL,
   219  		}},
   220  		true,
   221  	)
   222  	assert.Error(err)
   223  	assert.ErrorIs(err, ErrInvalidName)
   224  	assert.Len(sa.IndexedFields, 3)
   225  	assert.Equal("val1", vals["key1"])
   226  	assert.Equal(int64(2), vals["key2"])
   227  	assert.Equal(true, vals["key3"])
   228  
   229  	delete(sa.IndexedFields["key1"].Metadata, "type")
   230  	delete(sa.IndexedFields["key2"].Metadata, "type")
   231  	delete(sa.IndexedFields["key3"].Metadata, "type")
   232  
   233  	vals, err = Decode(sa, nil, true)
   234  	assert.Error(err)
   235  	assert.ErrorIs(err, ErrInvalidType)
   236  	assert.Len(vals, 3)
   237  	assert.Nil(vals["key1"])
   238  	assert.Nil(vals["key2"])
   239  	assert.Nil(vals["key3"])
   240  }