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  }