From e46de068c984110de991636c95475a6c44e2d546 Mon Sep 17 00:00:00 2001 From: Frederik Williams Date: Mon, 18 Dec 2017 10:02:08 +0100 Subject: [PATCH] release 3.4 --- .../queueit/knownuserv3/sdk/Constants.java | 1 + .../queueit/knownuserv3/sdk/KnownUser.java | 95 ++++++++------- .../knownuserv3/sdk/UserInQueueService.java | 14 ++- .../sdk/integrationconfig/Constants.java | 2 + .../IntegrationEvaluator.java | 110 +++++++++++------- .../sdk/integrationconfig/TriggerPart.java | 1 + .../knownuserv3/sdk/KnownUserTest.java | 46 +++++++- .../sdk/UserInQueueServiceTest.java | 13 +++ .../ComparisonOperatorHelperTest.java | 71 +++++++---- 9 files changed, 247 insertions(+), 106 deletions(-) diff --git a/SDK/src/queueit/knownuserv3/sdk/Constants.java b/SDK/src/queueit/knownuserv3/sdk/Constants.java index 4ad7bd9..ce18d3b 100644 --- a/SDK/src/queueit/knownuserv3/sdk/Constants.java +++ b/SDK/src/queueit/knownuserv3/sdk/Constants.java @@ -4,4 +4,5 @@ final class ActionType { public static final String CANCEL_ACTION = "Cancel"; public static final String QUEUE_ACTION = "Queue"; + public static final String IGNORE_ACTION = "Ignore"; } diff --git a/SDK/src/queueit/knownuserv3/sdk/KnownUser.java b/SDK/src/queueit/knownuserv3/sdk/KnownUser.java index 4a772c0..cc5b492 100644 --- a/SDK/src/queueit/knownuserv3/sdk/KnownUser.java +++ b/SDK/src/queueit/knownuserv3/sdk/KnownUser.java @@ -16,7 +16,7 @@ public class KnownUser { public static final String QueueITDebugKey = "queueitdebug"; private static IUserInQueueService _userInQueueService; - private static IUserInQueueService createUserInQueueService(HttpServletRequest request, HttpServletResponse response) { + private static IUserInQueueService getUserInQueueService(HttpServletRequest request, HttpServletResponse response) { if (_userInQueueService == null) { return new UserInQueueService(new UserInQueueStateCookieRepository(new CookieManager(request, response))); } @@ -71,44 +71,16 @@ public static RequestValidationResult validateRequestByIntegrationConfig(String return new RequestValidationResult(null, null, null, null); } + // unspecified or 'Queue' specified if(Utils.isNullOrWhiteSpace(matchedConfig.ActionType) || ActionType.QUEUE_ACTION.equals(matchedConfig.ActionType)) { - String targetUrl; - switch (matchedConfig.RedirectLogic) { - case "ForecedTargetUrl": // suuport for typo (fall through) - case "ForcedTargetUrl": - targetUrl = matchedConfig.ForcedTargetUrl; - break; - case "EventTargetUrl": - targetUrl = ""; - break; - default: - targetUrl = currentUrlWithoutQueueITToken; - break; - } - - QueueEventConfig queueConfig = new QueueEventConfig(); - queueConfig.setQueueDomain(matchedConfig.QueueDomain); - queueConfig.setCulture(matchedConfig.Culture); - queueConfig.setEventId(matchedConfig.EventId); - queueConfig.setExtendCookieValidity(matchedConfig.ExtendCookieValidity); - queueConfig.setLayoutName(matchedConfig.LayoutName); - queueConfig.setCookieValidityMinute(matchedConfig.CookieValidityMinute); - queueConfig.setCookieDomain(matchedConfig.CookieDomain); - queueConfig.setVersion(customerIntegrationInfo.Version); - - return resolveQueueRequestByLocalConfig( - targetUrl, queueitToken, queueConfig, customerId, request, response, secretKey, debugEntries); + return handleQueueAction(matchedConfig, currentUrlWithoutQueueITToken, customerIntegrationInfo, queueitToken, customerId, request, response, secretKey, debugEntries); } - // CancelQueueAction + else if (ActionType.CANCEL_ACTION.equals(matchedConfig.ActionType)){ + return handleCancelAction(matchedConfig, customerIntegrationInfo, currentUrlWithoutQueueITToken, queueitToken, customerId, request, response, secretKey, debugEntries); + } + // for all unknown types default to 'Ignore' else { - CancelEventConfig cancelConfig = new CancelEventConfig(); - cancelConfig.setQueueDomain(matchedConfig.QueueDomain); - cancelConfig.setEventId(matchedConfig.EventId); - cancelConfig.setCookieDomain(matchedConfig.CookieDomain); - cancelConfig.setVersion(customerIntegrationInfo.Version); - - return cancelRequestByLocalConfig( - currentUrlWithoutQueueITToken, queueitToken, cancelConfig, customerId, request, response, secretKey, debugEntries); + return handleIgnoreAction(request, response); } } finally { @@ -166,7 +138,7 @@ private static RequestValidationResult cancelRequestByLocalConfig( throw new Exception("QueueDomain from cancelConfig can not be null or empty."); } - IUserInQueueService userInQueueService = createUserInQueueService(request, response); + IUserInQueueService userInQueueService = getUserInQueueService(request, response); return userInQueueService.validateCancelRequest(targetUrl, cancelConfig, customerId, secretKey); } @@ -223,7 +195,7 @@ private static RequestValidationResult resolveQueueRequestByLocalConfig( queueitToken = ""; } - IUserInQueueService userInQueueService = createUserInQueueService(request, response); + IUserInQueueService userInQueueService = getUserInQueueService(request, response); return userInQueueService.validateQueueRequest(targetUrl, queueitToken, queueConfig, customerId, secretKey); } @@ -244,7 +216,7 @@ public static void extendQueueCookie(String eventId, throw new Exception("secretKey can not be null or empty."); } - IUserInQueueService userInQueueService = createUserInQueueService(request, response); + IUserInQueueService userInQueueService = getUserInQueueService(request, response); userInQueueService.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey); } @@ -288,6 +260,51 @@ private static String getOriginalUrl(HttpServletRequest request){ ? String.join("", request.getRequestURL(), "?",request.getQueryString()) : request.getRequestURL().toString(); } + + private static RequestValidationResult handleQueueAction(IntegrationConfigModel matchedConfig, String currentUrlWithoutQueueITToken, CustomerIntegration customerIntegrationInfo, String queueitToken, String customerId, HttpServletRequest request, HttpServletResponse response, String secretKey, Map debugEntries) throws Exception { + String targetUrl; + switch (matchedConfig.RedirectLogic) { + case "ForecedTargetUrl": // suuport for typo (fall through) + case "ForcedTargetUrl": + targetUrl = matchedConfig.ForcedTargetUrl; + break; + case "EventTargetUrl": + targetUrl = ""; + break; + default: + targetUrl = currentUrlWithoutQueueITToken; + break; + } + + QueueEventConfig queueConfig = new QueueEventConfig(); + queueConfig.setQueueDomain(matchedConfig.QueueDomain); + queueConfig.setCulture(matchedConfig.Culture); + queueConfig.setEventId(matchedConfig.EventId); + queueConfig.setExtendCookieValidity(matchedConfig.ExtendCookieValidity); + queueConfig.setLayoutName(matchedConfig.LayoutName); + queueConfig.setCookieValidityMinute(matchedConfig.CookieValidityMinute); + queueConfig.setCookieDomain(matchedConfig.CookieDomain); + queueConfig.setVersion(customerIntegrationInfo.Version); + + return resolveQueueRequestByLocalConfig( + targetUrl, queueitToken, queueConfig, customerId, request, response, secretKey, debugEntries); + } + + private static RequestValidationResult handleCancelAction(IntegrationConfigModel matchedConfig, CustomerIntegration customerIntegrationInfo, String currentUrlWithoutQueueITToken, String queueitToken, String customerId, HttpServletRequest request, HttpServletResponse response, String secretKey, Map debugEntries) throws Exception { + CancelEventConfig cancelConfig = new CancelEventConfig(); + cancelConfig.setQueueDomain(matchedConfig.QueueDomain); + cancelConfig.setEventId(matchedConfig.EventId); + cancelConfig.setCookieDomain(matchedConfig.CookieDomain); + cancelConfig.setVersion(customerIntegrationInfo.Version); + + return cancelRequestByLocalConfig( + currentUrlWithoutQueueITToken, queueitToken, cancelConfig, customerId, request, response, secretKey, debugEntries); + } + + private static RequestValidationResult handleIgnoreAction(HttpServletRequest request, HttpServletResponse response) { + IUserInQueueService userInQueueService = getUserInQueueService(request, response); + return userInQueueService.getIgnoreActionResult(); + } } interface ICookieManager { diff --git a/SDK/src/queueit/knownuserv3/sdk/UserInQueueService.java b/SDK/src/queueit/knownuserv3/sdk/UserInQueueService.java index f40886c..3fc6b0b 100644 --- a/SDK/src/queueit/knownuserv3/sdk/UserInQueueService.java +++ b/SDK/src/queueit/knownuserv3/sdk/UserInQueueService.java @@ -25,11 +25,13 @@ void extendQueueCookie( String cookieDomain, String secretKey ); + + RequestValidationResult getIgnoreActionResult(); } class UserInQueueService implements IUserInQueueService { - public static final String SDK_VERSION = "3.3.2"; + public static final String SDK_VERSION = "3.4.0"; private final IUserInQueueStateRepository _userInQueueStateRepository; public UserInQueueService( @@ -168,7 +170,10 @@ public void extendQueueCookie( @Override public RequestValidationResult validateCancelRequest( - String targetUrl, CancelEventConfig config, String customerId, String secretKey) throws Exception { + String targetUrl, + CancelEventConfig config, + String customerId, + String secretKey) throws Exception { StateInfo state = _userInQueueStateRepository.getState(config.getEventId(), secretKey); @@ -193,4 +198,9 @@ public RequestValidationResult validateCancelRequest( return new RequestValidationResult(ActionType.CANCEL_ACTION, config.getEventId(), null, null); } } + + @Override + public RequestValidationResult getIgnoreActionResult() { + return new RequestValidationResult(ActionType.IGNORE_ACTION, null, null, null); + } } diff --git a/SDK/src/queueit/knownuserv3/sdk/integrationconfig/Constants.java b/SDK/src/queueit/knownuserv3/sdk/integrationconfig/Constants.java index 6bec3d5..d9a5b89 100644 --- a/SDK/src/queueit/knownuserv3/sdk/integrationconfig/Constants.java +++ b/SDK/src/queueit/knownuserv3/sdk/integrationconfig/Constants.java @@ -22,6 +22,8 @@ final class ComparisonOperatorType { public static final String STARTS_WITH = "StartsWith"; public static final String ENDS_WITH = "EndsWith"; public static final String MATCHES_WITH = "MatchesWith"; + public static final String EQUALS_ANY = "EqualsAny"; + public static final String CONTAINS_ANY = "ContainsAny"; } final class LogicalOperatorType { diff --git a/SDK/src/queueit/knownuserv3/sdk/integrationconfig/IntegrationEvaluator.java b/SDK/src/queueit/knownuserv3/sdk/integrationconfig/IntegrationEvaluator.java index a439539..5246cab 100644 --- a/SDK/src/queueit/knownuserv3/sdk/integrationconfig/IntegrationEvaluator.java +++ b/SDK/src/queueit/knownuserv3/sdk/integrationconfig/IntegrationEvaluator.java @@ -3,8 +3,6 @@ import javax.servlet.http.Cookie; import java.util.regex.Matcher; import java.util.regex.Pattern; -import java.util.Map; -import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; interface IIntegrationEvaluator { @@ -81,7 +79,8 @@ public static boolean evaluate(TriggerPart triggerPart, String url) { triggerPart.IsNegative, triggerPart.IsIgnoreCase, getUrlPart(triggerPart, url), - triggerPart.ValueToCompare); + triggerPart.ValueToCompare, + triggerPart.ValuesToCompare); } private static String getUrlPart(TriggerPart triggerPart, String url) { @@ -127,7 +126,8 @@ public static boolean evaluate(TriggerPart triggerPart, Cookie[] cookieCollectio triggerPart.IsNegative, triggerPart.IsIgnoreCase, getCookie(triggerPart.CookieName, cookieCollection), - triggerPart.ValueToCompare); + triggerPart.ValueToCompare, + triggerPart.ValuesToCompare); } private static String getCookie(String cookieName, Cookie[] cookieCollection) { @@ -150,51 +150,67 @@ public static boolean evaluate(TriggerPart triggerPart, String userAgent) { triggerPart.IsNegative, triggerPart.IsIgnoreCase, userAgent, - triggerPart.ValueToCompare); + triggerPart.ValueToCompare, + triggerPart.ValuesToCompare); } } - final class HttpHeaderValidatorHelper { - public static boolean evaluate(TriggerPart triggerPart, HttpServletRequest request) - { - return ComparisonOperatorHelper.evaluate(triggerPart.Operator, - triggerPart.IsNegative, - triggerPart.IsIgnoreCase, - request.getHeader(triggerPart.HttpHeaderName), - triggerPart.ValueToCompare); - } +final class HttpHeaderValidatorHelper { + + public static boolean evaluate(TriggerPart triggerPart, HttpServletRequest request) + { + return ComparisonOperatorHelper.evaluate(triggerPart.Operator, + triggerPart.IsNegative, + triggerPart.IsIgnoreCase, + request.getHeader(triggerPart.HttpHeaderName), + triggerPart.ValueToCompare, + triggerPart.ValuesToCompare); } +} final class ComparisonOperatorHelper { - public static boolean evaluate(String opt, boolean isNegative, boolean isIgnoreCase, String left, String right) { - left = (left != null) ? left : ""; - right = (right != null) ? right : ""; + public static boolean evaluate( + String opt, + boolean isNegative, + boolean isIgnoreCase, + String value, + String valueToCompare, + String[] valuesToCompare) { + + value = (value != null) ? value : ""; + valueToCompare = (valueToCompare != null) ? valueToCompare : ""; + valuesToCompare = (valuesToCompare != null) ? valuesToCompare : new String[0]; + switch (opt) { case ComparisonOperatorType.EQUALS: - return equals(left, right, isNegative, isIgnoreCase); + return equals(value, valueToCompare, isNegative, isIgnoreCase); case ComparisonOperatorType.CONTAINS: - return contains(left, right, isNegative, isIgnoreCase); + return contains(value, valueToCompare, isNegative, isIgnoreCase); case ComparisonOperatorType.STARTS_WITH: - return startsWith(left, right, isNegative, isIgnoreCase); + return startsWith(value, valueToCompare, isNegative, isIgnoreCase); case ComparisonOperatorType.ENDS_WITH: - return endsWith(left, right, isNegative, isIgnoreCase); + return endsWith(value, valueToCompare, isNegative, isIgnoreCase); case ComparisonOperatorType.MATCHES_WITH: - return matchesWith(left, right, isNegative, isIgnoreCase); + return matchesWith(value, valueToCompare, isNegative, isIgnoreCase); + case ComparisonOperatorType.EQUALS_ANY: + return equalsAny(value, valuesToCompare, isNegative, isIgnoreCase); + case ComparisonOperatorType.CONTAINS_ANY: + return containsAny(value, valuesToCompare, isNegative, isIgnoreCase); default: return false; } } - private static boolean contains(String left, String right, boolean isNegative, boolean ignoreCase) { - if (right.equals("*")) { + private static boolean contains(String value, String valueToCompare, boolean isNegative, boolean ignoreCase) { + if (valueToCompare.equals("*")) { return true; } boolean evaluation; if (ignoreCase) { - evaluation = left.toUpperCase().contains(right.toUpperCase()); + evaluation = value.toUpperCase().contains(valueToCompare.toUpperCase()); } else { - evaluation = left.contains(right); + evaluation = value.contains(valueToCompare); } if (isNegative) { return !evaluation; @@ -203,13 +219,13 @@ private static boolean contains(String left, String right, boolean isNegative, b } } - private static boolean equals(String left, String right, boolean isNegative, boolean ignoreCase) { + private static boolean equals(String value, String valueToCompare, boolean isNegative, boolean ignoreCase) { boolean evaluation; if (ignoreCase) { - evaluation = left.toUpperCase().equals(right.toUpperCase()); + evaluation = value.toUpperCase().equals(valueToCompare.toUpperCase()); } else { - evaluation = left.equals(right); + evaluation = value.equals(valueToCompare); } if (isNegative) { @@ -219,13 +235,13 @@ private static boolean equals(String left, String right, boolean isNegative, boo } } - private static boolean endsWith(String left, String right, boolean isNegative, boolean ignoreCase) { + private static boolean endsWith(String value, String valueToCompare, boolean isNegative, boolean ignoreCase) { boolean evaluation; if (ignoreCase) { - evaluation = left.toUpperCase().endsWith(right.toUpperCase()); + evaluation = value.toUpperCase().endsWith(valueToCompare.toUpperCase()); } else { - evaluation = left.endsWith(right); + evaluation = value.endsWith(valueToCompare); } if (isNegative) { @@ -235,13 +251,13 @@ private static boolean endsWith(String left, String right, boolean isNegative, b } } - private static boolean startsWith(String left, String right, boolean isNegative, boolean ignoreCase) { + private static boolean startsWith(String value, String valueToCompare, boolean isNegative, boolean ignoreCase) { boolean evaluation; if (ignoreCase) { - evaluation = left.toUpperCase().startsWith(right.toUpperCase()); + evaluation = value.toUpperCase().startsWith(valueToCompare.toUpperCase()); } else { - evaluation = left.startsWith(right); + evaluation = value.startsWith(valueToCompare); } if (isNegative) { @@ -251,19 +267,35 @@ private static boolean startsWith(String left, String right, boolean isNegative, } } - private static boolean matchesWith(String left, String right, boolean isNegative, boolean isIgnoreCase) { + private static boolean matchesWith(String value, String valueToCompare, boolean isNegative, boolean isIgnoreCase) { Pattern pattern; if (isIgnoreCase) { - pattern = Pattern.compile(right, Pattern.CASE_INSENSITIVE); + pattern = Pattern.compile(valueToCompare, Pattern.CASE_INSENSITIVE); } else { - pattern = Pattern.compile(right); + pattern = Pattern.compile(valueToCompare); } - boolean evaluation = pattern.matcher(left).matches(); + boolean evaluation = pattern.matcher(value).matches(); if (isNegative) { return !evaluation; } else { return evaluation; } } + + private static boolean equalsAny(String value, String[] valuesToCompare, boolean isNegative, boolean isIgnoreCase) { + for (String valueToCompare : valuesToCompare) { + if(equals(value, valueToCompare, false, isIgnoreCase)) + return !isNegative; + } + return isNegative; + } + + private static boolean containsAny(String value, String[] valuesToCompare, boolean isNegative, boolean isIgnoreCase) { + for (String valueToCompare : valuesToCompare) { + if(contains(value, valueToCompare, false, isIgnoreCase)) + return !isNegative; + } + return isNegative; + } } diff --git a/SDK/src/queueit/knownuserv3/sdk/integrationconfig/TriggerPart.java b/SDK/src/queueit/knownuserv3/sdk/integrationconfig/TriggerPart.java index ad1bdb4..2dfe5af 100644 --- a/SDK/src/queueit/knownuserv3/sdk/integrationconfig/TriggerPart.java +++ b/SDK/src/queueit/knownuserv3/sdk/integrationconfig/TriggerPart.java @@ -5,6 +5,7 @@ public class TriggerPart { public String ValidatorType; public String Operator; public String ValueToCompare; + public String[] ValuesToCompare; public boolean IsNegative; public boolean IsIgnoreCase; //UrlValidator diff --git a/SDK/test/queueit/knownuserv3/sdk/KnownUserTest.java b/SDK/test/queueit/knownuserv3/sdk/KnownUserTest.java index 12c4839..fb7e725 100644 --- a/SDK/test/queueit/knownuserv3/sdk/KnownUserTest.java +++ b/SDK/test/queueit/knownuserv3/sdk/KnownUserTest.java @@ -42,7 +42,8 @@ class UserInQueueServiceMock implements IUserInQueueService { public ArrayList> validateQueueRequestCalls = new ArrayList<>(); public ArrayList> validateCancelRequestCalls = new ArrayList<>(); public ArrayList> extendQueueCookieCalls = new ArrayList<>(); - + public ArrayList> getIgnoreActionResultCalls = new ArrayList<>(); + @Override public RequestValidationResult validateQueueRequest(String targetUrl, String queueitToken, QueueEventConfig config, String customerId, String secretKey) throws Exception { ArrayList args = new ArrayList<>(); @@ -92,6 +93,12 @@ public void extendQueueCookie(String eventId, int cookieValidityMinute, String c args.add(secretKey); extendQueueCookieCalls.add(args); } + + @Override + public RequestValidationResult getIgnoreActionResult() { + getIgnoreActionResultCalls.add(new ArrayList<>()); + return null; + } } @Test @@ -944,6 +951,43 @@ public void validateRequestByIntegrationConfigEventTargetUrl() throws Exception assertTrue("".equals(mock.validateQueueRequestCalls.get(0).get(0))); } + @Test + public void validateRequestByIntegrationConfigIgnoreAction() throws Exception { + // Arrange + UserInQueueServiceMock mock = new UserInQueueServiceMock(); + KnownUser.setUserInQueueService(mock); + + TriggerPart triggerPart = new TriggerPart(); + triggerPart.Operator = "Contains"; + triggerPart.ValueToCompare = "event1"; + triggerPart.UrlPart = "PageUrl"; + triggerPart.ValidatorType = "UrlValidator"; + triggerPart.IsNegative = false; + triggerPart.IsIgnoreCase = true; + + TriggerModel trigger = new TriggerModel(); + trigger.LogicalOperator = "And"; + trigger.TriggerParts = new TriggerPart[]{triggerPart}; + + IntegrationConfigModel config = new IntegrationConfigModel(); + config.Name = "event1action"; + config.EventId = "event1"; + config.CookieDomain = "cookiedomain"; + config.Triggers = new TriggerModel[]{trigger}; + config.QueueDomain = "queuedomain"; + config.ActionType = ActionType.IGNORE_ACTION; + + CustomerIntegration customerIntegration = new CustomerIntegration(); + customerIntegration.Integrations = new IntegrationConfigModel[]{config}; + customerIntegration.Version = 3; + + // Act + KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueitToken", customerIntegration, "customerId", new HttpServletRequestMock(), null, "secretKey"); + + // Assert + assertTrue(mock.getIgnoreActionResultCalls.size() == 1); + } + @Test public void validateRequestByIntegrationConfigCancelAction() throws Exception { // Arrange diff --git a/SDK/test/queueit/knownuserv3/sdk/UserInQueueServiceTest.java b/SDK/test/queueit/knownuserv3/sdk/UserInQueueServiceTest.java index 0ddc8df..289896b 100644 --- a/SDK/test/queueit/knownuserv3/sdk/UserInQueueServiceTest.java +++ b/SDK/test/queueit/knownuserv3/sdk/UserInQueueServiceTest.java @@ -6,6 +6,8 @@ import java.util.HashMap; import java.util.regex.Matcher; import java.util.regex.Pattern; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import org.junit.Test; @@ -658,6 +660,17 @@ public void extendQueueCookie(String eventId, int cookieValidityMinute, String c assertTrue(expectedUrl.equals(result.getRedirectUrl())); assertTrue(config.getEventId().equals(result.getEventId())); } + + @Test + public void getIgnoreRequest() throws Exception { + UserInQueueService testObject = new UserInQueueService(null); + RequestValidationResult result = testObject.getIgnoreActionResult(); + assertTrue(ActionType.IGNORE_ACTION.equals(result.getActionType())); + assertFalse(result.doRedirect()); + assertNull(result.getEventId()); + assertNull(result.getQueueId()); + assertNull(result.getRedirectUrl()); + } public static class QueueITTokenGenerator { diff --git a/SDK/test/queueit/knownuserv3/sdk/integrationconfig/ComparisonOperatorHelperTest.java b/SDK/test/queueit/knownuserv3/sdk/integrationconfig/ComparisonOperatorHelperTest.java index 39faade..de9ed71 100644 --- a/SDK/test/queueit/knownuserv3/sdk/integrationconfig/ComparisonOperatorHelperTest.java +++ b/SDK/test/queueit/knownuserv3/sdk/integrationconfig/ComparisonOperatorHelperTest.java @@ -7,46 +7,67 @@ public class ComparisonOperatorHelperTest { @Test public void Evaluate_Equals() { - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, false, false, "test1", "test1")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, false, false, "test1", "Test1")); - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, false, true, "test1", "Test1")); - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, true, false, "test1", "Test1")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, true, false, "test1", "test1")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, true, true, "test1", "Test1")); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, false, false, "test1", "test1", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, false, false, "test1", "Test1", null)); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, false, true, "test1", "Test1", null)); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, true, false, "test1", "Test1", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, true, false, "test1", "test1", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS, true, true, "test1", "Test1", null)); } @Test public void Evaluate_Contains() { - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, false, false, "test_test1_test", "test1")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, false, false, "test_test1_test", "Test1")); - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, false, true, "test_test1_test", "Test1")); - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, true, false, "test_test1_test", "Test1")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, true, true, "test_test1", "Test1")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, true, false, "test_test1", "test1")); - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, false, false, "test_dsdsdsdtest1", "*")); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, false, false, "test_test1_test", "test1", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, false, false, "test_test1_test", "Test1", null)); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, false, true, "test_test1_test", "Test1", null)); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, true, false, "test_test1_test", "Test1", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, true, true, "test_test1", "Test1", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, true, false, "test_test1", "test1", null)); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS, false, false, "test_dsdsdsdtest1", "*", null)); } @Test public void Evaluate_StartsWith() { - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.STARTS_WITH, false, false, "test1_test1_test", "test1")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.STARTS_WITH, false, false, "test1_test1_test", "Test1")); - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.STARTS_WITH, false, true, "test1_test1_test", "Test1")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.STARTS_WITH, true, true, "test1_test1_test", "Test1")); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.STARTS_WITH, false, false, "test1_test1_test", "test1", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.STARTS_WITH, false, false, "test1_test1_test", "Test1", null)); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.STARTS_WITH, false, true, "test1_test1_test", "Test1", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.STARTS_WITH, true, true, "test1_test1_test", "Test1", null)); } @Test public void Evaluate_EndsWith() { - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.ENDS_WITH, false, false, "test1_test1_testshop", "shop")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.ENDS_WITH, false, false, "test1_test1_testshop2", "shop")); - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.ENDS_WITH, false, true, "test1_test1_testshop", "Shop")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.ENDS_WITH, true, true, "test1_test1_testshop", "Shop")); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.ENDS_WITH, false, false, "test1_test1_testshop", "shop", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.ENDS_WITH, false, false, "test1_test1_testshop2", "shop", null)); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.ENDS_WITH, false, true, "test1_test1_testshop", "Shop", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.ENDS_WITH, true, true, "test1_test1_testshop", "Shop", null)); } @Test public void Evaluate_MatchesWith() { - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.MATCHES_WITH, false, false, "test1_test1_testshop", ".*shop.*")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.MATCHES_WITH, false, false, "test1_test1_testshop2", ".*Shop.*")); - assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.MATCHES_WITH, false, true, "test1_test1_testshop", ".*Shop.*")); - assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.MATCHES_WITH, true, true, "test1_test1_testshop", ".*Shop.*")); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.MATCHES_WITH, false, false, "test1_test1_testshop", ".*shop.*", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.MATCHES_WITH, false, false, "test1_test1_testshop2", ".*Shop.*", null)); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.MATCHES_WITH, false, true, "test1_test1_testshop", ".*Shop.*", null)); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.MATCHES_WITH, true, true, "test1_test1_testshop", ".*Shop.*", null)); + } + + @Test + public void Evaluate_EqualsAny() { + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS_ANY, false, false, "test1", null, new String[]{"test1"})); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS_ANY, false, false, "test1", null, new String[]{"Test1"})); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS_ANY, false, true, "test1", null, new String[]{"Test1"})); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS_ANY, true, false, "test1", null, new String[]{"Test1"})); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS_ANY, true, false, "test1", null, new String[]{"test1"})); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.EQUALS_ANY, true, true, "test1", null, new String[]{"Test1"})); + } + + @Test + public void Evaluate_ContainsAny() { + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS_ANY, false, false, "test_test1_test", null, new String[]{"test1"})); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS_ANY, false, false, "test_test1_test", null, new String[]{"Test1"})); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS_ANY, false, true, "test_test1_test", null, new String[]{"Test1"})); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS_ANY, true, false, "test_test1_test", null, new String[]{"Test1"})); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS_ANY, true, true, "test_test1", null, new String[]{"Test1"})); + assertFalse(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS_ANY, true, false, "test_test1", null, new String[]{"test1"})); + assertTrue(ComparisonOperatorHelper.evaluate(ComparisonOperatorType.CONTAINS_ANY, false, false, "test_dsdsdsdtest1", null, new String[]{"*"})); } }