github.com/Axway/agent-sdk@v1.1.101/pkg/filter/filter_test.go (about)

     1  package filter
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  )
     8  
     9  var name1Val = "value 1"
    10  var name2Val = "value 2"
    11  var name3Val = "value 3"
    12  var name4Val = "value 4"
    13  
    14  var filterData = map[string]string{
    15  	"name1": name1Val,
    16  	"name2": name2Val,
    17  	"name3": name3Val,
    18  	"name4": name4Val,
    19  }
    20  
    21  var filterDataWithStringPointer = map[string]*string{
    22  	"name1": &name1Val,
    23  	"name2": &name2Val,
    24  	"name3": &name3Val,
    25  	"name4": &name4Val,
    26  }
    27  
    28  var filterDataWithStringArrary = map[string][]string{
    29  	"name-test":            {name1Val, "v 1", "v-1"},
    30  	"name-test-multi-dash": {name1Val, "v 1", "v-1"},
    31  	"name1":                {name1Val, "v 1", "v-1"},
    32  	"name2":                {name2Val, "v 2", "v-2"},
    33  	"name3":                {name3Val, "v 3", "v-3"},
    34  	"name4":                {name4Val, "v 4", "v-4"},
    35  }
    36  
    37  func TestSimpleFilter(t *testing.T) {
    38  	SetSupportedCallExprTypes(defaultSupportedExpr)
    39  
    40  	assertFilter(t, "tag.name == \"value 1\"", filterData, false)
    41  	assertFilter(t, "tag.name1 == \"value 1\"", filterData, true)
    42  	assertFilter(t, "tag.name1 == \"value 1,v 1,v-1\"", filterDataWithStringArrary, true)
    43  	assertFilter(t, "tag.name1 != \"value 1\"", filterData, false)
    44  
    45  	assertFilter(t, "tag.Any() == \"value 1\"", filterDataWithStringPointer, true)
    46  	assertFilter(t, "tag.Any() == \"somevalue\"", filterDataWithStringPointer, false)
    47  	assertFilter(t, "tag.Any() != \"value 1\"", filterDataWithStringPointer, false)
    48  	assertFilter(t, "tag.Any() != \"somevalue\"", filterDataWithStringPointer, true)
    49  
    50  	assertFilter(t, "tag.name1.Exists()", filterData, true)
    51  	assertFilter(t, "tag.name.Exists()", filterData, false)
    52  	assertFilter(t, "tag.name1.Exists() == false", filterData, false)
    53  	assertFilter(t, "tag.name.Exists() != true", filterData, true)
    54  
    55  	assertFilter(t, "tag.name1.Contains(\"val\")", filterData, true)
    56  	assertFilter(t, "tag.name1.Contains(\"someval\")", filterData, false)
    57  	assertFilter(t, "tag.name1.Contains(\"val\") == true", filterData, true)
    58  	assertFilter(t, "tag.name1.Contains(\"val\") != true", filterData, false)
    59  
    60  	assertFilter(t, "tag.name1.Contains(\"v-1\")", filterDataWithStringArrary, true)
    61  	assertFilter(t, "tag.name1.Contains(\"value 1,v 1\")", filterDataWithStringArrary, true)
    62  	assertFilter(t, "tag.name2.Contains(\"value 1,v 1\")", filterDataWithStringArrary, false)
    63  
    64  	assertFilter(t, "tag.name1.MatchRegEx(\"(val){1}\")", filterDataWithStringArrary, true)
    65  	assertFilter(t, "tag.name1.MatchRegEx(\"(na){1}\")", filterDataWithStringArrary, false)
    66  	assertFilter(t, "tag.name1.MatchRegEx(\".*(value 1|value 2).*\")", filterDataWithStringArrary, true)
    67  	assertFilter(t, "tag.name2.MatchRegEx(\".*(value 1|value 2).*\")", filterDataWithStringArrary, true)
    68  	assertFilter(t, "tag.name3.MatchRegEx(\".*(value 1|value 2).*\")", filterDataWithStringArrary, false)
    69  
    70  	assertFilter(t, "tag.name1.MatchRegEx(\"(val){1}\") == true", filterDataWithStringArrary, true)
    71  	assertFilter(t, "tag.name1.MatchRegEx(\"(val){1}\") != true", filterDataWithStringArrary, false)
    72  
    73  	assertFilter(t, "tag.MatchRegEx(\"name-test\") == true", filterDataWithStringArrary, true)
    74  	assertFilter(t, "tag.MatchRegEx(\"name-t.*\") == true", filterDataWithStringArrary, true)
    75  	assertFilter(t, "tag.MatchRegEx(\"name-test-multi-dash\")", filterDataWithStringArrary, true)
    76  	assertFilter(t, "tag.MatchRegEx(\"name-test-2\")", filterDataWithStringArrary, false)
    77  	assertFilter(t, "tag.MatchRegEx(\"name-test-2\") == false", filterDataWithStringArrary, true)
    78  
    79  	assertFilter(t, "tag.name-test.Exists()", filterDataWithStringArrary, true)
    80  	assertFilter(t, "tag.name-test-multi-dash.Exists()", filterDataWithStringArrary, true)
    81  	assertFilter(t, "tag.name-test-2.Exists()", filterDataWithStringArrary, false)
    82  	assertFilter(t, "tag.name-test-2.Exists() == false", filterDataWithStringArrary, true)
    83  }
    84  
    85  func TestCompoundFilter(t *testing.T) {
    86  	SetSupportedCallExprTypes(defaultSupportedExpr)
    87  
    88  	assertFilter(t, "tag.name1 == \"value 1\" || tag.name2 == \"value 2\"", filterData, true)
    89  	assertFilter(t, "tag.name1 == \"missing\" || tag.name2 == \"value 2\"", filterData, true)
    90  	assertFilter(t, "tag.name1 == \"missing\" || tag.name2 == \"missing\"", filterData, false)
    91  
    92  	assertFilter(t, "tag.name1 == \"value 1\" && tag.name2 == \"value 2\"", filterData, true)
    93  	assertFilter(t, "tag.name1 == \"missing\" && tag.name2 == \"value 2\"", filterData, false)
    94  	assertFilter(t, "tag.name1 == \"missing\" && tag.name2 == \"missing\"", filterData, false)
    95  
    96  	assertFilter(t, "tag.Any() == \"value 1\" || tag.name2 == \"missing\" && tag.name2 == \"missing\"", filterData, true)
    97  	assertFilter(t, "tag.Any() == \"missing\" || tag.name2 == \"missing\" && tag.name2 == \"missing\"", filterData, false)
    98  
    99  	assertFilter(t, "tag.name1.Exists() || tag.name2 == \"value 2\"", filterData, true)
   100  	assertFilter(t, "tag.name1.Exists() && tag.name2 == \"value 2\"", filterData, true)
   101  	assertFilter(t, "tag.name1.Exists() || tag.name2 == \"value 1\"", filterData, true)
   102  	assertFilter(t, "tag.name1.Exists() == false && tag.name2 == \"value 2\"", filterData, false)
   103  	assertFilter(t, "tag.name.Exists() != true && tag.Any() == \"value 2\"", filterData, true)
   104  
   105  	assertFilter(t, "tag.name1.Exists() && tag.name1.Contains(\"val\")", filterData, true)
   106  	assertFilter(t, "tag.name1.Exists() && tag.name1.Contains(\"something\")", filterData, false)
   107  	assertFilter(t, "tag.name.Exists() && tag.name1.Contains(\"val\")", filterData, false)
   108  
   109  	assertFilter(t, "tag.Any() == \"value 1,v 1,v-1\" || tag.name2.Exists() || tag.name3.Contains(\"v-3\") || tag.name4.MatchRegEx(\"(val){1}\")", filterDataWithStringArrary, true)
   110  	assertFilter(t, "tag.Any() == \"someotherval\" || tag.name2.Exists() || tag.name3.Contains(\"v-3\") || tag.name4.MatchRegEx(\"(val){1}\")", filterDataWithStringArrary, true)
   111  	assertFilter(t, "tag.Any() == \"someotherval\" || tag.name22.Exists() || tag.name3.Contains(\"v-3\") || tag.name4.MatchRegEx(\"(val){1}\")", filterDataWithStringArrary, true)
   112  	assertFilter(t, "tag.Any() == \"someotherval\" || tag.name22.Exists() || tag.name3.Contains(\"somevalue\") || tag.name4.MatchRegEx(\"(val){1}\")", filterDataWithStringArrary, true)
   113  	assertFilter(t, "tag.Any() == \"someotherval\" || tag.name22.Exists() || tag.name3.Contains(\"somevalue\") || tag.name4.MatchRegEx(\"(something){1}\")", filterDataWithStringArrary, false)
   114  
   115  	assertFilter(t, "tag.Any() == \"value 1,v 1,v-1\" && tag.name2.Exists() && tag.name3.Contains(\"v-3\") && tag.name4.MatchRegEx(\"(val){1}\")", filterDataWithStringArrary, true)
   116  	assertFilter(t, "tag.Any() == \"someotherval\" || tag.name2.Exists() && tag.name3.Contains(\"v-3\") || tag.name4.MatchRegEx(\"(val){1}\")", filterDataWithStringArrary, true)
   117  
   118  	assertFilter(t, "tag.MatchRegEx(\"name-test-multi-dash\") && tag.MatchRegEx(\"name-test-2\") == false", filterDataWithStringArrary, true)
   119  	assertFilter(t, "tag.name-test.Exists() && tag.MatchRegEx(\"name-test-multi-dash\")", filterDataWithStringArrary, true)
   120  	assertFilter(t, "tag.name-test-2.Exists() && tag.MatchRegEx(\"name-test-multi-dash\")", filterDataWithStringArrary, false)
   121  	assertFilter(t, "tag.name-test-multi-dash.Exists() == true && tag.MatchRegEx(\"name-test-2\") == false", filterDataWithStringArrary, true)
   122  	assertFilter(t, "tag.name-test-2.Exists() == false && tag.MatchRegEx(\"name-test-multi-dash\")", filterDataWithStringArrary, true)
   123  
   124  }
   125  
   126  func assertFilter(t *testing.T, filterConfig string, filterData interface{}, expectedResult bool) {
   127  	agentFilter, err := NewFilter(filterConfig)
   128  	assert.NotNil(t, agentFilter)
   129  	assert.Nil(t, err)
   130  	b := agentFilter.Evaluate(filterData)
   131  	assert.Equal(t, expectedResult, b)
   132  }
   133  
   134  func TestFilterParsingError(t *testing.T) {
   135  	SetSupportedCallExprTypes(defaultSupportedExpr)
   136  
   137  	// golang Syntax OK, but have filter syntax errors
   138  	assertFilterSyntaxErr(t, "a == b", "Unrecognized condition")
   139  	assertFilterSyntaxErr(t, "something.name1 == \"value 1\"", "Invalid selector type")
   140  	assertFilterSyntaxErr(t, "tag.name1", "Unrecognized expression")
   141  	assertFilterSyntaxErr(t, "\"value\" == \"value\"", "Unrecognized condition")
   142  	assertFilterSyntaxErr(t, "tag.name1 & \"value\"", "Invalid operator")
   143  
   144  	// Unsupported condition grouping
   145  	assertFilterSyntaxErr(t, "tag.name1 == \"value 1\" && (tag.name1 == \"value 1\")", "Unrecognized expression")
   146  	assertFilterSyntaxErr(t, "\"tag.name1 == value\"", "Unrecognized expression")
   147  
   148  	// Syntax Errors
   149  	assertFilterSyntaxErr(t, "tag.name1 = \"value 1\"", "Syntax error: expected '==', found '='")
   150  	assertFilterSyntaxErr(t, "tag.name1 == \"value 1\" tag.name1 != \"value 1\"", "Syntax error: expected ';', found tag")
   151  	assertFilterSyntaxErr(t, "tag.name1 == ", "Syntax error: expected ';', found 'EOF'")
   152  
   153  	// Call Expression Sytax Error
   154  	assertFilterSyntaxErr(t, "tag.Match(\"something\")", "unsupported call")
   155  
   156  	// Additional arguments
   157  	assertFilterSyntaxErr(t, "tag.Any(\"something\") == \"something\"", "syntax error, unrecognized argument(s)")
   158  	assertFilterSyntaxErr(t, "tag.name.Exists(\"something\")", "syntax error, unrecognized argument(s)")
   159  	assertFilterSyntaxErr(t, "tag.name.Contains(\"one\", \"two\")", "syntax error, unrecognized argument(s)")
   160  	assertFilterSyntaxErr(t, "tag.name.MatchRegEx(\"one\", \"two\")", "syntax error, unrecognized argument(s)")
   161  
   162  	// Missing arguments
   163  	assertFilterSyntaxErr(t, "tag.name.Contains()", "syntax error, missing argument")
   164  	assertFilterSyntaxErr(t, "tag.name.MatchRegEx()", "syntax error, missing argument")
   165  
   166  	// Invalid Regular expression
   167  	assertFilterSyntaxErr(t, "tag.name.MatchRegEx(\".*[\")", "Invalid regular expression")
   168  
   169  }
   170  
   171  func assertFilterSyntaxErr(t *testing.T, filterConfig, expectedErr string) {
   172  	agentFilter, err := NewFilter(filterConfig)
   173  	assert.Nil(t, agentFilter)
   174  	assert.NotNil(t, err)
   175  	assert.Contains(t, err.Error(), expectedErr)
   176  }
   177  
   178  func TestOverrideSupportedExpr(t *testing.T) {
   179  	SetSupportedCallExprTypes([]CallType{EXISTS})
   180  
   181  	assertFilterSyntaxErr(t, "tag.name1 == \"value 1\"", "unsupported condition")
   182  	assertFilterSyntaxErr(t, "tag.Any() == \"value 1\"", "unsupported condition")
   183  	assertFilterSyntaxErr(t, "tag.name1.Contains(\"val\")", "unsupported condition")
   184  	assertFilterSyntaxErr(t, "tag.name1.MatchRegEx(\"(val){1}\")", "unsupported condition")
   185  	assertFilter(t, "tag.name1.Exists()", filterData, true)
   186  	assertFilter(t, "tag.name1.Exists() || tag.nothing.Exists()", filterData, true)
   187  	assertFilter(t, "tag.name1.Exists() && tag.nothing.Exists()", filterData, false)
   188  
   189  	assertFilterSyntaxErr(t, "tag.name1.Exists() && tag.name1.MatchRegEx(\"(val){1}\")", "unsupported condition")
   190  }