github.com/TIBCOSoftware/flogo-lib@v0.5.9/core/mapper/exprmapper/expression/function_test.go (about) 1 package expression 2 3 import ( 4 "bytes" 5 "encoding/json" 6 "fmt" 7 "strconv" 8 "testing" 9 10 "github.com/TIBCOSoftware/flogo-lib/core/data" 11 12 "github.com/TIBCOSoftware/flogo-lib/core/mapper/exprmapper/expression/function" 13 "github.com/stretchr/testify/assert" 14 ) 15 16 func TestFunctionConcatWithSpace(t *testing.T) { 17 18 e, err := ParseExpression(`flogo.concat("This", "is",string.concat("my","first"),"gocc",string.concat("lexer","and","parser"),string.concat("go","program","!!!"))`) 19 if err != nil { 20 t.Fatal(err) 21 t.Failed() 22 } 23 if err != nil { 24 t.Fatal(err) 25 t.Failed() 26 } 27 v, err := e.Eval() 28 if err != nil { 29 t.Fatal(err) 30 t.Failed() 31 } 32 33 assert.Equal(t, "Thisismyfirstgocclexerandparsergoprogram!!!", function.HandleToSingleOutput(v).(string)) 34 fmt.Println("Result:", v) 35 } 36 37 func TestFunctionConcatWithMultiSpace(t *testing.T) { 38 39 e, err := ParseExpression(`flogo.concat("This", " is" , " WI")`) 40 if err != nil { 41 t.Fatal(err) 42 t.Failed() 43 } 44 v, err := e.Eval() 45 if err != nil { 46 t.Fatal(err) 47 t.Failed() 48 } 49 assert.Equal(t, "This is WI", function.HandleToSingleOutput(v).(string)) 50 fmt.Println("Result:", v) 51 } 52 func TestFunctionConcat(t *testing.T) { 53 54 e, err := ParseExpression(`flogo.concat("This","is",string.concat("my","first"),"gocc",string.concat("lexer","and","parser"),string.concat("go","program","!!!"))`) 55 if err != nil { 56 t.Fatal(err) 57 t.Failed() 58 } 59 v, err := e.Eval() 60 if err != nil { 61 t.Fatal(err) 62 t.Failed() 63 } 64 assert.Equal(t, "Thisismyfirstgocclexerandparsergoprogram!!!", function.HandleToSingleOutput(v).(string)) 65 fmt.Println("Result:", v) 66 } 67 68 func TestFunctionLength(t *testing.T) { 69 e, err := ParseExpression(`string.length("lixingwang")`) 70 if err != nil { 71 t.Fatal(err) 72 t.Failed() 73 } 74 v, err := e.Eval() 75 if err != nil { 76 t.Fatal(err) 77 t.Failed() 78 } 79 assert.Equal(t, int(10), function.HandleToSingleOutput(v).(int)) 80 81 fmt.Println("Result:", function.HandleToSingleOutput(v)) 82 } 83 84 func TestFunctionCombine(t *testing.T) { 85 e, err := ParseExpression(`string.concat("Beijing",string.tostring(string.length("lixingwang")))`) 86 if err != nil { 87 t.Fatal(err) 88 t.Failed() 89 } 90 v, err := e.Eval() 91 if err != nil { 92 t.Fatal(err) 93 t.Failed() 94 } 95 assert.Equal(t, "Beijing10", function.HandleToSingleOutput(v).(string)) 96 97 fmt.Println("Result:", function.HandleToSingleOutput(v)) 98 } 99 100 func TestFunctionCombine2(t *testing.T) { 101 e, err := ParseExpression(`string.concat("Beijing",string.tostring(string.length("lixingwang")))`) 102 if err != nil { 103 t.Fatal(err) 104 t.Failed() 105 } 106 v, err := e.Eval() 107 if err != nil { 108 t.Fatal(err) 109 t.Failed() 110 } 111 assert.Equal(t, "Beijing10", function.HandleToSingleOutput(v).(string)) 112 113 fmt.Println("Result:", function.HandleToSingleOutput(v)) 114 } 115 116 func TestFunctionError(t *testing.T) { 117 v, err := ParseExpression(`string.concat("Beijing",string.tostring(2017))`) 118 if err != nil { 119 assert.NotNil(t, err) 120 fmt.Println("Result", v) 121 } else { 122 t.Failed() 123 } 124 } 125 126 func TestFunctionWithRefMapping(t *testing.T) { 127 e, err := ParseExpression(`string.concat($A3.query.result,"data")`) 128 if err != nil { 129 t.Fatal(err) 130 t.Failed() 131 } 132 s, _ := json.Marshal(e) 133 fmt.Println(string(s)) 134 v, err := e.Eval() 135 if err != nil { 136 t.Fatal(err) 137 t.Failed() 138 } 139 assert.Equal(t, "$A3.query.resultdata", function.HandleToSingleOutput(v).(string)) 140 141 fmt.Println("Result:", function.HandleToSingleOutput(v)) 142 } 143 144 func TestFunctionWithRefMapping2(t *testing.T) { 145 e, err := ParseExpression(`string.concat($A2.message,"lixingwang")`) 146 if err != nil { 147 t.Fatal(err) 148 t.Failed() 149 } 150 v, err := e.Eval() 151 if err != nil { 152 t.Fatal(err) 153 t.Failed() 154 } 155 assert.Equal(t, "$A2.messagelixingwang", function.HandleToSingleOutput(v).(string)) 156 157 fmt.Println("Result:", function.HandleToSingleOutput(v)) 158 } 159 160 func TestFunctionWithTag(t *testing.T) { 161 e, err := ParseExpression(`flogo.concat($A2.message,"lixingwang")`) 162 if err != nil { 163 t.Fatal(err) 164 t.Failed() 165 } 166 v, err := e.Eval() 167 if err != nil { 168 t.Fatal(err) 169 t.Failed() 170 } 171 assert.Equal(t, "$A2.messagelixingwang", function.HandleToSingleOutput(v).(string)) 172 173 fmt.Println("Result:", function.HandleToSingleOutput(v)) 174 } 175 176 func TestFunctionWithSpaceInRef(t *testing.T) { 177 e, err := ParseExpression(`string.concat($Marketo Get Lead by Id.output.result[0].firstName,$Marketo Get Lead by Id.output.result[0].lastName)`) 178 if err != nil { 179 t.Fatal(err) 180 t.Failed() 181 } 182 v, err := e.Eval() 183 if err != nil { 184 t.Fatal(err) 185 t.Failed() 186 } 187 assert.Equal(t, "$Marketo Get Lead by Id.output.result[0].firstName$Marketo Get Lead by Id.output.result[0].lastName", function.HandleToSingleOutput(v).(string)) 188 189 fmt.Println("Result:", function.HandleToSingleOutput(v)) 190 } 191 192 func TestFunctionWithPackage(t *testing.T) { 193 e, err := ParseExpression(`string.concat($A2.message,"lixingwang")`) 194 if err != nil { 195 t.Fatal(err) 196 t.Failed() 197 } 198 v, err := e.Eval() 199 if err != nil { 200 t.Fatal(err) 201 t.Failed() 202 } 203 assert.Equal(t, "$A2.messagelixingwang", function.HandleToSingleOutput(v).(string)) 204 205 fmt.Println("Result:", function.HandleToSingleOutput(v)) 206 } 207 208 func TestFunctionWithNil(t *testing.T) { 209 e, err := ParseExpression(`string.concat("test","nil")`) 210 if err != nil { 211 t.Fatal(err) 212 t.Failed() 213 } 214 v, err := e.Eval() 215 if err != nil { 216 t.Fatal(err) 217 t.Failed() 218 } 219 assert.Equal(t, "testnil", function.HandleToSingleOutput(v).(string)) 220 221 e, err = ParseExpression(`string.concat("test",nil)`) 222 if err != nil { 223 t.Fatal(err) 224 t.Failed() 225 } 226 v, err = e.Eval() 227 if err != nil { 228 t.Fatal(err) 229 t.Failed() 230 } 231 assert.Equal(t, "test", function.HandleToSingleOutput(v).(string)) 232 233 } 234 235 func TestFunctionWithSpecialFiled(t *testing.T) { 236 e, err := ParseExpression(`$activity[lixingwang].myattri["name.name"][0]>2`) 237 if err != nil { 238 t.Fatal(err) 239 t.Failed() 240 } 241 _, err = e.Eval() 242 assert.NotNil(t, err) 243 } 244 245 func TestFunctionWithNegtiveNumber(t *testing.T) { 246 d := `{"test":"test", "obj":{"id":-123, "value":"value"}}` 247 testScope := GetSimpleScope("name", d) 248 249 e, err := ParseExpression(`string.length($.name.obj.value) >= -2`) 250 if err != nil { 251 t.Fatal(err) 252 t.Failed() 253 } 254 v, err := e.EvalWithScope(testScope, data.GetBasicResolver()) 255 assert.Nil(t, err) 256 assert.Equal(t, true, v) 257 } 258 259 type Concat struct { 260 } 261 262 func init() { 263 function.Registry(&Concat{}) 264 } 265 266 func (s *Concat) GetName() string { 267 return "concat" 268 } 269 270 func (s *Concat) GetCategory() string { 271 return "flogo" 272 } 273 274 func (s *Concat) Eval(strs ...string) string { 275 log.Infof("Start flogo:concat function with parameters %s", strs) 276 var buffer bytes.Buffer 277 278 for _, v := range strs { 279 buffer.WriteString(v) 280 } 281 log.Debugf("Done flogo:concat function with result %s", buffer.String()) 282 return buffer.String() 283 } 284 285 type PConcat struct { 286 } 287 288 func init() { 289 function.Registry(&PConcat{}) 290 } 291 292 func (s *PConcat) GetName() string { 293 return "string.concat" 294 } 295 296 func (s *PConcat) GetCategory() string { 297 return "" 298 } 299 300 func (s *PConcat) Eval(strs ...string) string { 301 log.Debugf("Start string:concat function with parameters %s", strs) 302 var buffer bytes.Buffer 303 304 for _, v := range strs { 305 buffer.WriteString(v) 306 } 307 log.Debugf("Done string:concat function with result %s", buffer.String()) 308 return buffer.String() 309 } 310 311 type Length struct { 312 } 313 314 func init() { 315 function.Registry(&Length{}) 316 } 317 318 func (s *Length) GetName() string { 319 return "length" 320 } 321 322 func (s *Length) GetCategory() string { 323 return "string" 324 } 325 326 func (s *Length) Eval(str string) int { 327 log.Debugf("Return the length of a string \"%s\"", str) 328 var l int 329 //l = len([]rune(str)) 330 l = len(str) 331 log.Debugf("Done calculating the length %d", l) 332 return l 333 } 334 335 type PanicFunc struct { 336 } 337 338 func init() { 339 function.Registry(&PanicFunc{}) 340 } 341 342 func (s *PanicFunc) GetName() string { 343 return "panic" 344 } 345 346 func (s *PanicFunc) GetCategory() string { 347 return "panic" 348 } 349 350 func (s *PanicFunc) Eval() string { 351 panic("Panic happened") 352 return "panic" 353 } 354 355 func TestPanictFunction(t *testing.T) { 356 e, err := ParseExpression(`panic.panic()`) 357 assert.Nil(t, err) 358 v, err := e.Eval() 359 assert.NotNil(t, err) 360 assert.Nil(t, v) 361 } 362 363 func TestNumberLenFunction(t *testing.T) { 364 v, err := ParseExpression(`string.length("hello,world")`) 365 log.Info(v) 366 assert.NotNil(t, v) 367 assert.Nil(t, err) 368 369 } 370 371 type String struct { 372 } 373 374 func init() { 375 function.Registry(&String{}) 376 } 377 378 func (s *String) GetName() string { 379 return "tostring" 380 } 381 382 func (s *String) GetCategory() string { 383 return "string" 384 } 385 386 func (s *String) Eval(in interface{}) string { 387 log.Debugf("Start String function with parameters %s", in) 388 389 switch in.(type) { 390 case string: 391 return in.(string) 392 case float64: 393 return strconv.FormatFloat(in.(float64), 'f', -1, 64) 394 case int32, int8, int16, int64: 395 //v := int64(in) 396 return strconv.FormatInt(in.(int64), 10) 397 case int: 398 return strconv.Itoa(in.(int)) 399 case *int: 400 return strconv.Itoa(*in.(*int)) 401 case uint, uint8, uint16, uint32, uint64: 402 //v := int64(in) 403 return strconv.FormatInt(in.(int64), 10) 404 default: 405 str, err := data.CoerceToString(in) 406 if err != nil { 407 log.Errorf("Convert to string error %s", err.Error()) 408 } 409 return str 410 } 411 }