github.com/GuanceCloud/cliutils@v1.1.21/pipeline/ptinput/funcs/fn_pt_kvs_test.go (about)

     1  // Unless explicitly stated otherwise all files in this repository are licensed
     2  // under the MIT License.
     3  // This product includes software developed at Guance Cloud (https://www.guance.com/).
     4  // Copyright 2021-present Guance, Inc.
     5  
     6  package funcs
     7  
     8  import (
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/GuanceCloud/cliutils/pipeline/ptinput"
    13  	"github.com/GuanceCloud/cliutils/point"
    14  	"github.com/stretchr/testify/assert"
    15  )
    16  
    17  func TestPtKvsTag(t *testing.T) {
    18  	funcs := []*Function{
    19  		FnPtKvsGet,
    20  		FnPtKvsDel,
    21  		FnPtKvsSet,
    22  		FnPtKvsKeys,
    23  	}
    24  
    25  	cases := []struct {
    26  		name, pl, in string
    27  		keyName      string
    28  		expect       interface{}
    29  		fail         bool
    30  	}{
    31  		{
    32  			name: "set1",
    33  			pl: `
    34  			pt_kvs_set("key0", "abc", true)
    35  			pt_kvs_set("key1", pt_kvs_get("key0"))
    36  			pt_kvs_del("key0")
    37  			if pt_kvs_get("key0") == nil {
    38  				for k in pt_kvs_keys() {
    39  					if k == "key1" {
    40  						pt_kvs_set("key2", pt_kvs_get("key1"))
    41  					}
    42  				}
    43  			}
    44  			`,
    45  			keyName: "key2",
    46  			expect:  "abc",
    47  		},
    48  		{
    49  			name: "set2",
    50  			pl: `
    51  			pt_kvs_set("key1", 1, true)
    52  			pt_kvs_set("key2", 2)
    53  			count = 0
    54  			if "key1"  in pt_kvs_keys(tags=true, fields=false) {
    55  				count += 1
    56  			} 
    57  			
    58  			fields_key = pt_kvs_keys(false)
    59  
    60  			if "key1" in fields_key {
    61  				count = -1
    62  			}
    63  
    64  			if "key2" in fields_key {
    65  				count +=2
    66  			}
    67  
    68  			if count == 3 {
    69  				pt_kvs_set("test_ok", 1, true)
    70  			}
    71  
    72  			`,
    73  			keyName: "test_ok",
    74  			expect:  "1",
    75  		},
    76  		{
    77  			name: "set4",
    78  			pl: `
    79  			pt_kvs_set("key1",  as_tag=true, value=1.1)
    80  			`,
    81  			keyName: "key1",
    82  			expect:  "1.1",
    83  		},
    84  		{
    85  			name: "set5",
    86  			pl: `
    87  			pt_kvs_set("key1", true, true)
    88  			`,
    89  			keyName: "key1",
    90  			expect:  "true",
    91  		},
    92  		{
    93  			name: "set6",
    94  			pl: `
    95  			key_name = "key1"
    96  			pt_kvs_set(key_name, [1,2], true)
    97  			`,
    98  			keyName: "key1",
    99  			expect:  "[1,2]",
   100  		},
   101  		{
   102  			name: "set7",
   103  			pl: `
   104  			pt_kvs_set("key1", {"a":1, "b":2}, true)
   105  			`,
   106  			keyName: "key1",
   107  			expect:  `{"a":1,"b":2}`,
   108  		},
   109  		{
   110  			name: "set8",
   111  			pl: `
   112  			pt_kvs_set("key1", nil, true)
   113  			`,
   114  			keyName: "key1",
   115  			expect:  "",
   116  		},
   117  		{
   118  			name: "set8",
   119  			pl: `
   120  			pt_kvs_set("_", "1", true)
   121  			`,
   122  			keyName: "_",
   123  			expect:  "1",
   124  		},
   125  	}
   126  
   127  	for idx, tc := range cases {
   128  		t.Run(tc.name, func(t *testing.T) {
   129  			script, err := parseScipt(tc.pl, funcs)
   130  			if err != nil {
   131  				if tc.fail {
   132  					t.Logf("[%d]expect error: %s", idx, err)
   133  				} else {
   134  					t.Errorf("[%d] failed: %s", idx, err)
   135  				}
   136  				return
   137  			}
   138  
   139  			pt := ptinput.NewPlPoint(
   140  				point.Logging, "test", nil, map[string]any{"message": tc.in}, time.Now())
   141  			errR := script.Run(pt, nil)
   142  			if errR != nil {
   143  				t.Fatal(errR.Error())
   144  			}
   145  
   146  			v, _, _ := pt.Get(tc.keyName)
   147  			assert.Equal(t, tc.expect, v)
   148  			t.Logf("[%d] PASS", idx)
   149  
   150  		})
   151  	}
   152  }
   153  
   154  func TestPtKvsSet(t *testing.T) {
   155  	funcs := []*Function{
   156  		FnPtKvsGet,
   157  		FnPtKvsDel,
   158  		FnPtKvsSet,
   159  		FnPtKvsKeys,
   160  	}
   161  
   162  	cases := []struct {
   163  		name, pl, in string
   164  		keyName      string
   165  		expect       interface{}
   166  		fail         bool
   167  	}{
   168  		{
   169  			name: "set1",
   170  			pl: `
   171  			pt_kvs_set("key1", "abc")
   172  			`,
   173  			keyName: "key1",
   174  			expect:  "abc",
   175  		},
   176  		{
   177  			name: "set2",
   178  			pl: `
   179  			pt_kvs_set("key1", 1)
   180  			`,
   181  			keyName: "key1",
   182  			expect:  int64(1),
   183  		},
   184  		{
   185  			name: "set3",
   186  			pl: `
   187  			pt_kvs_set("key1", 1)
   188  			`,
   189  			keyName: "key1",
   190  			expect:  int64(1),
   191  		},
   192  		{
   193  			name: "set4",
   194  			pl: `
   195  			pt_kvs_set("key1", 1.)
   196  			`,
   197  			keyName: "key1",
   198  			expect:  float64(1.),
   199  		},
   200  		{
   201  			name: "set5",
   202  			pl: `
   203  			pt_kvs_set("key1", true)
   204  			`,
   205  			keyName: "key1",
   206  			expect:  true,
   207  		},
   208  		{
   209  			name: "set6",
   210  			pl: `
   211  			pt_kvs_set("key1", [1,2])
   212  			`,
   213  			keyName: "key1",
   214  			expect:  "[1,2]",
   215  		},
   216  		{
   217  			name: "set7",
   218  			pl: `
   219  			pt_kvs_set("key1", {"a":1, "b":2})
   220  			`,
   221  			keyName: "key1",
   222  			expect:  `{"a":1,"b":2}`,
   223  		},
   224  		{
   225  			name: "set8",
   226  			pl: `
   227  			pt_kvs_set("key1", nil)
   228  			`,
   229  			keyName: "key1",
   230  			expect:  nil,
   231  		},
   232  	}
   233  
   234  	for idx, tc := range cases {
   235  		t.Run(tc.name, func(t *testing.T) {
   236  			script, err := parseScipt(tc.pl, funcs)
   237  			if err != nil {
   238  				if tc.fail {
   239  					t.Logf("[%d]expect error: %s", idx, err)
   240  				} else {
   241  					t.Errorf("[%d] failed: %s", idx, err)
   242  				}
   243  				return
   244  			}
   245  
   246  			pt := ptinput.NewPlPoint(
   247  				point.Logging, "test", nil, map[string]any{"message": tc.in}, time.Now())
   248  			errR := script.Run(pt, nil)
   249  			if errR != nil {
   250  				t.Fatal(errR.Error())
   251  			}
   252  
   253  			v, _, _ := pt.Get(tc.keyName)
   254  			assert.Equal(t, tc.expect, v)
   255  			t.Logf("[%d] PASS", idx)
   256  
   257  		})
   258  	}
   259  }