github.com/TIBCOSoftware/flogo-lib@v0.5.9/core/mapper/exprmapper/exprmapper_test.go (about)

     1  package exprmapper
     2  
     3  import (
     4  	"testing"
     5  
     6  	"fmt"
     7  	"strings"
     8  
     9  	"github.com/TIBCOSoftware/flogo-lib/core/data"
    10  	"github.com/TIBCOSoftware/flogo-lib/logger"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  //1. activity mapping
    15  func TestActivityMapping(t *testing.T) {
    16  	v, err := expressMap("$activity[a1].field.id", "field", GetTestResolver())
    17  	assert.Nil(t, err)
    18  	assert.Equal(t, "d", v)
    19  }
    20  
    21  //Literal string
    22  func TestMappingRef(t *testing.T) {
    23  	v, err := expressMap("dddd", "field", GetTestResolver())
    24  	assert.Nil(t, err)
    25  	assert.Equal(t, "dddd", v)
    26  }
    27  
    28  //2. flow mapping
    29  func TestFlowMapping(t *testing.T) {
    30  	v, err := expressMapWithFlow("$.field.id", "field", data.GetBasicResolver())
    31  	assert.Nil(t, err)
    32  	assert.Equal(t, "d", v)
    33  }
    34  
    35  //3. function
    36  func TestGetMapValueFunction(t *testing.T) {
    37  	v, err := expressMap(`string.concat("ddddd",$activity[a1].field.id)`, "field", GetTestResolver())
    38  	assert.Nil(t, err)
    39  	assert.Equal(t, "dddddd", v)
    40  	v, err = expressMap(`string.concat("ddddd",$activity[a1].field.id, string.concat($activity[a1].field.id,$activity[a1].field.id))`, "field", GetTestResolver())
    41  	assert.Nil(t, err)
    42  	assert.Equal(t, "dddddddd", v)
    43  }
    44  
    45  //4. function with different type
    46  func TestGetMapValueFunctionTypes(t *testing.T) {
    47  
    48  	v, err := expressMap(`string.concat(123,$activity[a1].field.id)`, "field", GetTestResolver())
    49  	assert.Nil(t, err)
    50  	assert.Equal(t, "123d", v)
    51  
    52  	v, err = expressMap(`string.concat("s-",$activity[a1].field.id, string.concat($activity[a1].field.id,$activity[a1].field.id),true)`, "field", GetTestResolver())
    53  	assert.Nil(t, err)
    54  	assert.Equal(t, "s-dddtrue", v)
    55  
    56  	v, err = expressMap(`string.concat(123,$activity[a1].field.id, "dddd", 450)`, "field", GetTestResolver())
    57  	assert.Nil(t, err)
    58  	assert.Equal(t, "123ddddd450", v)
    59  }
    60  
    61  //5. expression
    62  //6. ternary expression
    63  func TestGetMapValueExpression(t *testing.T) {
    64  
    65  	v, err := expressMapBoolMapToField(`string.length(string.concat("ddddd",$activity[a1].field.id)) == 6`, "field", GetTestResolver())
    66  	assert.Nil(t, err)
    67  	assert.Equal(t, true, v)
    68  
    69  	v, err = expressMapBoolMapToField(`$activity[a1].field.id == "d"`, "field", GetTestResolver())
    70  	assert.Nil(t, err)
    71  	assert.Equal(t, true, v)
    72  
    73  	v, err = expressMapBoolMapToField(`($activity[a1].field.id == "d") == true`, "field", GetTestResolver())
    74  	assert.Nil(t, err)
    75  	assert.Equal(t, true, v)
    76  
    77  	v, err = expressMap(`$activity[a1].field.id == "d" ? $activity[a1].field.id : string.concat("ssss",$activity[a1].field.id)`, "field", GetTestResolver())
    78  	assert.Nil(t, err)
    79  	assert.Equal(t, "d", v)
    80  
    81  	v, err = expressMap(`$activity[a1].field.id == "d" ? string.concat("ssss",$activity[a1].field.id) : $activity[a1].field.id`, "field", GetTestResolver())
    82  	assert.Nil(t, err)
    83  	assert.Equal(t, "ssssd", v)
    84  
    85  	v, err = expressMap(`$activity[a1].field.id != "d" ? string.concat("ssss",$activity[a1].field.id) : $activity[a1].field.id`, "field", GetTestResolver())
    86  	assert.Nil(t, err)
    87  	assert.Equal(t, "d", v)
    88  
    89  	v, err = expressMap(`$activity[a1].field.id != "d" ? "dddd":"ssss"`, "field", GetTestResolver())
    90  	assert.Nil(t, err)
    91  	assert.Equal(t, "ssss", v)
    92  
    93  	v, err = expressMap(`$activity[a1].field.id == "d" ? "dddd":"ssss"`, "field", GetTestResolver())
    94  	assert.Nil(t, err)
    95  	assert.Equal(t, "dddd", v)
    96  
    97  	v, err = expressMap(` 2>1 ? "dddd":"ssss"`, "field", GetTestResolver())
    98  	assert.Nil(t, err)
    99  	assert.Equal(t, "dddd", v)
   100  
   101  	v, err = expressMap(` 2<1 ? "dddd":"ssss"`, "field", GetTestResolver())
   102  	assert.Nil(t, err)
   103  	assert.Equal(t, "ssss", v)
   104  
   105  }
   106  
   107  func TestOperatorPriority(t *testing.T) {
   108  
   109  	v, err := expressMap(`string.concat(123,$activity[a1].field.id) == "123d" && $activity[a1].field.id =="d"`, "field", GetTestResolver())
   110  	assert.Nil(t, err)
   111  	assert.Equal(t, "true", v)
   112  
   113  	v, err = expressMap(`string.concat(123,$activity[a1].field.id) == "123d" && $activity[a1].field.id !="d"`, "field", GetTestResolver())
   114  	assert.Nil(t, err)
   115  
   116  	assert.Equal(t, "false", v)
   117  
   118  }
   119  
   120  func getSimpleScope(name, value string, fieldType data.Type) data.Scope {
   121  	a, _ := data.NewAttribute(name, fieldType, value)
   122  	maps := make(map[string]*data.Attribute)
   123  	maps[name] = a
   124  	scope := data.NewFixedScope(maps)
   125  	scope.SetAttrValue(name, value)
   126  	return scope
   127  }
   128  
   129  func GetObjectFieldScope(name, value string) data.Scope {
   130  	return getSimpleScope(name, value, data.TypeObject)
   131  }
   132  
   133  func GetStringFieldScope(name, value string) data.Scope {
   134  	return getSimpleScope(name, value, data.TypeString)
   135  }
   136  
   137  func GetBoolFieldScope(name, value string) data.Scope {
   138  	return getSimpleScope(name, value, data.TypeBoolean)
   139  }
   140  
   141  func GetComplexxFieldScope(name, value string) data.Scope {
   142  	return getSimpleScope(name, value, data.TypeComplexObject)
   143  }
   144  
   145  //For test  purpuse copy it from flogo-contrib
   146  var resolver = &TestResolver{}
   147  
   148  func GetTestResolver() data.Resolver {
   149  	return resolver
   150  }
   151  
   152  type TestResolver struct {
   153  }
   154  
   155  func (r *TestResolver) Resolve(toResolve string, scope data.Scope) (value interface{}, err error) {
   156  
   157  	var details *data.ResolutionDetails
   158  
   159  	if strings.HasPrefix(toResolve, "${") {
   160  		details, err = data.GetResolutionDetailsOld(toResolve)
   161  	} else if strings.HasPrefix(toResolve, "$") {
   162  		details, err = data.GetResolutionDetails(toResolve[1:])
   163  	} else {
   164  		return data.SimpleScopeResolve(toResolve, scope)
   165  	}
   166  
   167  	if err != nil {
   168  		return nil, err
   169  	}
   170  
   171  	if details == nil {
   172  		return nil, fmt.Errorf("unable to determine resolver for %s", toResolve)
   173  	}
   174  
   175  	switch details.ResolverName {
   176  	case "activity":
   177  		attr, exists := scope.GetAttr("_A." + details.Item + "." + details.Property)
   178  		if !exists {
   179  			return nil, fmt.Errorf("failed to resolve activity attr: '%s', not found in flow", details.Property)
   180  		}
   181  		value = attr.Value()
   182  	default:
   183  		return nil, fmt.Errorf("unsupported resolver: %s", details.ResolverName)
   184  	}
   185  
   186  	if details.Path != "" {
   187  		value, err = data.PathGetValue(value, details.Path)
   188  		if err != nil {
   189  			logger.Error(err.Error())
   190  			return nil, err
   191  		}
   192  	}
   193  
   194  	return value, nil
   195  }
   196  
   197  func expressMap(from, to string, resolver data.Resolver) (interface{}, error) {
   198  	mapDef := &data.MappingDef{Type: data.MtExpression, Value: from, MapTo: to}
   199  	inputScope := GetObjectFieldScope("_A.a1.field", `{"id":"d"}`)
   200  	outputScope := GetStringFieldScope("field", "")
   201  	err := MapExpreesion(mapDef, inputScope, outputScope, resolver)
   202  	if err != nil {
   203  		return nil, err
   204  	}
   205  	arr, ok := outputScope.GetAttr("field")
   206  	if !ok {
   207  		return nil, fmt.Errorf("Cannot find attribute [%s] in output scope", "field")
   208  	}
   209  	return arr.Value(), nil
   210  }
   211  
   212  func expressMapBoolMapToField(from, to string, resolver data.Resolver) (interface{}, error) {
   213  	mapDef := &data.MappingDef{Type: data.MtExpression, Value: from, MapTo: to}
   214  	inputScope := GetObjectFieldScope("_A.a1.field", `{"id":"d"}`)
   215  	outputScope := GetBoolFieldScope("field", "")
   216  	err := MapExpreesion(mapDef, inputScope, outputScope, resolver)
   217  	if err != nil {
   218  		return nil, err
   219  	}
   220  	arr, ok := outputScope.GetAttr("field")
   221  	if !ok {
   222  		return nil, fmt.Errorf("Cannot find attribute [%s] in output scope", "field")
   223  	}
   224  	return arr.Value(), nil
   225  }
   226  
   227  func expressMapWithFlow(from, to string, resolver data.Resolver) (interface{}, error) {
   228  	mapDef := &data.MappingDef{Type: data.MtExpression, Value: from, MapTo: to}
   229  	inputScope := GetObjectFieldScope("field", `{"id":"d"}`)
   230  	outputScope := GetStringFieldScope("field", "")
   231  	err := MapExpreesion(mapDef, inputScope, outputScope, resolver)
   232  	if err != nil {
   233  		return nil, err
   234  	}
   235  	arr, ok := outputScope.GetAttr("field")
   236  	if !ok {
   237  		return nil, fmt.Errorf("Cannot find attribute [%s] in output scope", "field")
   238  	}
   239  	return arr.Value(), nil
   240  }