From 8dd3a19bbd37c42d2291c3fb34651908f7039a30 Mon Sep 17 00:00:00 2001 From: Frederik Williams Date: Mon, 2 Mar 2020 12:07:28 +0100 Subject: [PATCH] Release 3.6 --- lib/queueit_knownuserv3.rb | 1 + .../connector_diagnostics.rb | 69 ++ .../integration_config_helpers.rb | 51 +- lib/queueit_knownuserv3/known_user.rb | 140 ++- lib/queueit_knownuserv3/models.rb | 22 +- lib/queueit_knownuserv3/queue_url_params.rb | 84 +- .../user_in_queue_service.rb | 99 +- .../user_in_queue_state_cookie_repository.rb | 2 +- queueit_knownuserv3.gemspec | 5 +- .../test_integration_config_helpers.rb | 24 - test/queueit_knownuserv3/test_known_user.rb | 1035 ++++++++++++----- .../test_queue_url_params.rb | 25 +- .../test_user_in_queue_service.rb | 93 +- 13 files changed, 1126 insertions(+), 524 deletions(-) create mode 100644 lib/queueit_knownuserv3/connector_diagnostics.rb diff --git a/lib/queueit_knownuserv3.rb b/lib/queueit_knownuserv3.rb index 70b9576..101d791 100644 --- a/lib/queueit_knownuserv3.rb +++ b/lib/queueit_knownuserv3.rb @@ -1,5 +1,6 @@ require_relative "queueit_knownuserv3/known_user" require_relative "queueit_knownuserv3/models" +require_relative "queueit_knownuserv3/connector_diagnostics" require_relative "queueit_knownuserv3/queue_url_params" require_relative "queueit_knownuserv3/user_in_queue_state_cookie_repository" require_relative "queueit_knownuserv3/user_in_queue_service" diff --git a/lib/queueit_knownuserv3/connector_diagnostics.rb b/lib/queueit_knownuserv3/connector_diagnostics.rb new file mode 100644 index 0000000..c9de7ef --- /dev/null +++ b/lib/queueit_knownuserv3/connector_diagnostics.rb @@ -0,0 +1,69 @@ +module QueueIt + class ConnectorDiagnostics + attr_accessor :isEnabled + attr_accessor :hasError + attr_accessor :validationResult + + def initialize + @isEnabled = false + @hasError = false + @validationResult = nil + end + + def setStateWithTokenError(customerId, errorCode) + @hasError = true + @validationResult = RequestValidationResult.new( + "ConnectorDiagnosticsRedirect", + nil, nil, + "https://" + customerId + ".api2.queue-it.net/" + customerId + "/diagnostics/connector/error/?code=" + errorCode, + nil, nil) + end + + def setStateWithSetupError() + @hasError = true + @validationResult = RequestValidationResult.new( + "ConnectorDiagnosticsRedirect", + nil, nil, + "https://api2.queue-it.net/diagnostics/connector/error/?code=setup", + nil, nil) + end + + def self.verify(customerId, secretKey, queueitToken) + diagnostics = ConnectorDiagnostics.new + + qParams = QueueUrlParams.extractQueueParams(queueitToken) + + if(qParams == nil) + return diagnostics + end + + if(qParams.redirectType == nil) + return diagnostics + end + + if(not qParams.redirectType.upcase.eql?("DEBUG")) + return diagnostics + end + + if(Utils.isNilOrEmpty(customerId) or Utils.isNilOrEmpty(secretKey)) + diagnostics.setStateWithSetupError() + return diagnostics + end + + calculatedHash = OpenSSL::HMAC.hexdigest('sha256', secretKey, qParams.queueITTokenWithoutHash) + if(not qParams.hashCode.eql?(calculatedHash)) + diagnostics.setStateWithTokenError(customerId, "hash") + return diagnostics + end + + if(qParams.timeStamp < Time.now.getutc.tv_sec) + diagnostics.setStateWithTokenError(customerId, "timestamp") + return diagnostics + end + + diagnostics.isEnabled = true + + return diagnostics + end + end +end \ No newline at end of file diff --git a/lib/queueit_knownuserv3/integration_config_helpers.rb b/lib/queueit_knownuserv3/integration_config_helpers.rb index 3d02618..ddff909 100644 --- a/lib/queueit_knownuserv3/integration_config_helpers.rb +++ b/lib/queueit_knownuserv3/integration_config_helpers.rb @@ -211,12 +211,6 @@ def self.evaluate(opt, isNegative, ignoreCase, value, valueToCompare, valuesToCo return ComparisonOperatorHelper.equals(value, valueToCompare, isNegative, ignoreCase) when "Contains" return ComparisonOperatorHelper.contains(value, valueToCompare, isNegative, ignoreCase) - when "StartsWith" - return ComparisonOperatorHelper.startsWith(value, valueToCompare, isNegative, ignoreCase) - when "EndsWith" - return ComparisonOperatorHelper.endsWith(value, valueToCompare, isNegative, ignoreCase) - when "MatchesWith" - return ComparisonOperatorHelper.matchesWith(value, valueToCompare, isNegative, ignoreCase) when "EqualsAny" return ComparisonOperatorHelper.equalsAny(value, valuesToCompare, isNegative, ignoreCase) when "ContainsAny" @@ -241,7 +235,7 @@ def self.equals(value, valueToCompare, isNegative, ignoreCase) end def self.contains(value, valueToCompare, isNegative, ignoreCase) - if(valueToCompare.eql? "*") + if((valueToCompare.eql? "*") && !(value.empty? || value.nil?)) return true end @@ -258,49 +252,6 @@ def self.contains(value, valueToCompare, isNegative, ignoreCase) end end - def self.startsWith(value, valueToCompare, isNegative, ignoreCase) - if(ignoreCase) - evaluation = value.upcase.start_with? valueToCompare.upcase - else - evaluation = value.start_with? valueToCompare - end - - if(isNegative) - return !evaluation - else - return evaluation - end - end - - def self.endsWith(value, valueToCompare, isNegative, ignoreCase) - if(ignoreCase) - evaluation = value.upcase.end_with? valueToCompare.upcase - else - evaluation = value.end_with? valueToCompare - end - - if(isNegative) - return !evaluation - else - return evaluation - end - end - - def self.matchesWith(value, valueToCompare, isNegative, ignoreCase) - if(ignoreCase) - pattern = Regexp.new(valueToCompare, Regexp::IGNORECASE) - else - pattern = Regexp.new(valueToCompare) - end - - evaluation = pattern.match(value) != nil - if(isNegative) - return !evaluation - else - return evaluation - end - end - def self.equalsAny(value, valuesToCompare, isNegative, ignoreCase) valuesToCompare.each do |valueToCompare| if (ComparisonOperatorHelper.equals(value, valueToCompare, false, ignoreCase)) diff --git a/lib/queueit_knownuserv3/known_user.rb b/lib/queueit_knownuserv3/known_user.rb index 5b0ad58..ce56f87 100644 --- a/lib/queueit_knownuserv3/known_user.rb +++ b/lib/queueit_knownuserv3/known_user.rb @@ -51,26 +51,6 @@ def self.logMoreRequestDetails(debugEntries, request) end private_class_method :logMoreRequestDetails - def self.getIsDebug(queueitToken, secretKey) - qParams = QueueUrlParams.extractQueueParams(queueitToken) - if(qParams == nil) - return false - end - - redirectType = qParams.redirectType - if(redirectType == nil) - return false - end - - if (redirectType.upcase.eql?("DEBUG")) - calculatedHash = OpenSSL::HMAC.hexdigest('sha256', secretKey, qParams.queueITTokenWithoutHash) - valid = qParams.hashCode.eql?(calculatedHash) - return valid - end - return false - end - private_class_method :getIsDebug - def self.setDebugCookie(debugEntries, cookieJar) if(debugEntries == nil || debugEntries.length == 0) return @@ -86,9 +66,11 @@ def self.setDebugCookie(debugEntries, cookieJar) end private_class_method :setDebugCookie - def self._resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries) - isDebug = getIsDebug(queueitToken, secretKey) + def self._resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries, isDebug) + if(isDebug) + debugEntries["SdkVersion"] = UserInQueueService::SDK_VERSION + debugEntries["Runtime"] = getRuntime() debugEntries["TargetUrl"] = targetUrl debugEntries["QueueitToken"] = queueitToken debugEntries["OriginalUrl"] = getRealOriginalUrl(request) @@ -137,10 +119,12 @@ def self._resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, end private_class_method :_resolveQueueRequestByLocalConfig - def self._cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries) - targetUrl = generateTargetUrl(targetUrl, request) - isDebug = getIsDebug(queueitToken, secretKey) + def self._cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries, isDebug) + targetUrl = generateTargetUrl(targetUrl, request) + if(isDebug) + debugEntries["SdkVersion"] = UserInQueueService::SDK_VERSION + debugEntries["Runtime"] = getRuntime() debugEntries["TargetUrl"] = targetUrl debugEntries["QueueitToken"] = queueitToken debugEntries["OriginalUrl"] = getRealOriginalUrl(request) @@ -204,40 +188,64 @@ def self.extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKe def self.resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request) debugEntries = Hash.new + connectorDiagnostics = ConnectorDiagnostics.verify(customerId, secretKey, queueitToken) + + if(connectorDiagnostics.hasError) + return connectorDiagnostics.validationResult + end begin targetUrl = generateTargetUrl(targetUrl, request) - return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries) + return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries, connectorDiagnostics.isEnabled) + rescue Exception => e + if(connectorDiagnostics.isEnabled) + debugEntries["Exception"] = e.message + end + raise e ensure setDebugCookie(debugEntries, request.cookie_jar) end end - def self.validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken, queueitToken, integrationsConfigString, customerId, secretKey, request) - if(Utils.isNilOrEmpty(currentUrlWithoutQueueITToken)) - raise KnownUserError, "currentUrlWithoutQueueITToken can not be nil or empty." - end - - if(Utils.isNilOrEmpty(integrationsConfigString)) - raise KnownUserError, "integrationsConfigString can not be nil or empty." + def self.validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken, queueitToken, integrationConfigJson, customerId, secretKey, request) + debugEntries = Hash.new + customerIntegration = Hash.new + connectorDiagnostics = ConnectorDiagnostics.verify(customerId, secretKey, queueitToken) + + if(connectorDiagnostics.hasError) + return connectorDiagnostics.validationResult end - - debugEntries = Hash.new begin - customerIntegration = JSON.parse(integrationsConfigString) - - isDebug = getIsDebug(queueitToken, secretKey) - if(isDebug) - debugEntries["ConfigVersion"] = customerIntegration["Version"] + if(connectorDiagnostics.isEnabled) + debugEntries["SdkVersion"] = UserInQueueService::SDK_VERSION + debugEntries["Runtime"] = getRuntime() debugEntries["PureUrl"] = currentUrlWithoutQueueITToken debugEntries["QueueitToken"] = queueitToken debugEntries["OriginalUrl"] = getRealOriginalUrl(request) logMoreRequestDetails(debugEntries, request) end - + + customerIntegration = JSON.parse(integrationConfigJson) + + if(connectorDiagnostics.isEnabled) + if(customerIntegration.length != 0 and customerIntegration["Version"] != nil) + debugEntries["ConfigVersion"] = customerIntegration["Version"] + else + debugEntries["ConfigVersion"] = "NULL" + end + end + + if(Utils.isNilOrEmpty(currentUrlWithoutQueueITToken)) + raise KnownUserError, "currentUrlWithoutQueueITToken can not be nil or empty." + end + + if(customerIntegration.length == 0 || customerIntegration["Version"] == nil) + raise KnownUserError, "integrationConfigJson is not valid json." + end + integrationEvaluator = IntegrationEvaluator.new matchedConfig = integrationEvaluator.getMatchedIntegrationConfig(customerIntegration, currentUrlWithoutQueueITToken, request) - if(isDebug) + if(connectorDiagnostics.isEnabled) if(matchedConfig == nil) debugEntries["MatchedConfig"] = "NULL" else @@ -246,33 +254,37 @@ def self.validateRequestByIntegrationConfig(currentUrlWithoutQueueITToken, queue end if(matchedConfig == nil) - return RequestValidationResult.new(nil, nil, nil, nil, nil) + return RequestValidationResult.new(nil, nil, nil, nil, nil, nil) end # unspecified or 'Queue' specified if(!matchedConfig.key?("ActionType") || Utils.isNilOrEmpty(matchedConfig["ActionType"]) || matchedConfig["ActionType"].eql?(ActionTypes::QUEUE)) - return handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries) + return handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, + customerId, secretKey, matchedConfig, request, debugEntries, connectorDiagnostics.isEnabled) elsif(matchedConfig["ActionType"].eql?(ActionTypes::CANCEL)) - return handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries) + return handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, + customerId, secretKey, matchedConfig, request, debugEntries, connectorDiagnostics.isEnabled) # for all unknown types default to 'Ignore' else userInQueueService = getUserInQueueService(request.cookie_jar) - result = userInQueueService.getIgnoreActionResult() + result = userInQueueService.getIgnoreActionResult(matchedConfig["Name"]) result.isAjaxResult = isQueueAjaxCall(request) return result end - - rescue StandardError => stdErr - raise KnownUserError, "integrationConfiguration text was not valid: " + stdErr.message + rescue Exception => e + if(connectorDiagnostics.isEnabled) + debugEntries["Exception"] = e.message + end + raise e ensure setDebugCookie(debugEntries, request.cookie_jar) end end - def self.handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries) + def self.handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries, isDebug) queueConfig = QueueEventConfig.new queueConfig.eventId = matchedConfig["EventId"] queueConfig.queueDomain = matchedConfig["QueueDomain"] @@ -282,7 +294,8 @@ def self.handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customer queueConfig.extendCookieValidity = matchedConfig["ExtendCookieValidity"] queueConfig.cookieValidityMinute = matchedConfig["CookieValidityMinute"] queueConfig.version = customerIntegration["Version"] - + queueConfig.actionName = matchedConfig["Name"] + case matchedConfig["RedirectLogic"] when "ForcedTargetUrl" targetUrl = matchedConfig["ForcedTargetUrl"] @@ -292,23 +305,34 @@ def self.handleQueueAction(currentUrlWithoutQueueITToken, queueitToken, customer targetUrl = generateTargetUrl(currentUrlWithoutQueueITToken, request) end - return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries) + return _resolveQueueRequestByLocalConfig(targetUrl, queueitToken, queueConfig, customerId, secretKey, request, debugEntries, isDebug) end - def self.handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries) + def self.handleCancelAction(currentUrlWithoutQueueITToken, queueitToken, customerIntegration, customerId, secretKey, matchedConfig, request, debugEntries, isDebug) cancelConfig = CancelEventConfig.new cancelConfig.eventId = matchedConfig["EventId"] cancelConfig.queueDomain = matchedConfig["QueueDomain"] cancelConfig.cookieDomain = matchedConfig["CookieDomain"] cancelConfig.version = customerIntegration["Version"] - - return _cancelRequestByLocalConfig(currentUrlWithoutQueueITToken, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries) + cancelConfig.actionName = matchedConfig["Name"] + + return _cancelRequestByLocalConfig(currentUrlWithoutQueueITToken, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries, isDebug) end def self.cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request) debugEntries = Hash.new + connectorDiagnostics = ConnectorDiagnostics.verify(customerId, secretKey, queueitToken) + + if(connectorDiagnostics.hasError) + return connectorDiagnostics.validationResult + end begin - return _cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries) + return _cancelRequestByLocalConfig(targetUrl, queueitToken, cancelConfig, customerId, secretKey, request, debugEntries, connectorDiagnostics.isEnabled) + rescue Exception => e + if(connectorDiagnostics.isEnabled) + debugEntries["Exception"] = e.message + end + raise e ensure setDebugCookie(debugEntries, request.cookie_jar) end @@ -319,6 +343,10 @@ def self.getRealOriginalUrl(request) # Therefore we need this method to be able to access the 'real' original url. return request.env["rack.url_scheme"] + "://" + request.env["HTTP_HOST"] + request.original_fullpath end + + def self.getRuntime() + return RUBY_VERSION.to_s + end end class CookieManager diff --git a/lib/queueit_knownuserv3/models.rb b/lib/queueit_knownuserv3/models.rb index d098dbd..ae64d8e 100644 --- a/lib/queueit_knownuserv3/models.rb +++ b/lib/queueit_knownuserv3/models.rb @@ -11,6 +11,12 @@ def self.toString(value) end return value.to_s end + def self.urlEncode(value) + return CGI.escape(value).gsub("+", "%20").gsub("%7E", "~") + end + def self.urlDecode(value) + return CGI.unescape(value) + end end class CancelEventConfig @@ -18,19 +24,22 @@ class CancelEventConfig attr_accessor :queueDomain attr_accessor :cookieDomain attr_accessor :version + attr_accessor :actionName def initialize @eventId = nil @queueDomain = nil @cookieDomain = nil @version = nil + @actionName = "unspecified" end def toString return "EventId:" + Utils.toString(eventId) + "&Version:" + Utils.toString(version) + "&QueueDomain:" + Utils.toString(queueDomain) + - "&CookieDomain:" + Utils.toString(cookieDomain) + "&CookieDomain:" + Utils.toString(cookieDomain) + + "&ActionName:" + Utils.toString(actionName) end end @@ -43,6 +52,7 @@ class QueueEventConfig attr_accessor :cookieValidityMinute attr_accessor :cookieDomain attr_accessor :version + attr_accessor :actionName def initialize @eventId = nil @@ -53,6 +63,7 @@ def initialize @cookieValidityMinute = nil @cookieDomain = nil @version = nil + @actionName = "unspecified" end def toString @@ -63,7 +74,8 @@ def toString "&ExtendCookieValidity:" + Utils.toString(extendCookieValidity) + "&CookieValidityMinute:" + Utils.toString(cookieValidityMinute) + "&LayoutName:" + Utils.toString(layoutName) + - "&Culture:" + Utils.toString(culture) + "&Culture:" + Utils.toString(culture) + + "&ActionName:" + Utils.toString(actionName) end end @@ -73,14 +85,16 @@ class RequestValidationResult attr_reader :queueId attr_reader :redirectUrl attr_reader :redirectType + attr_accessor :actionName attr_accessor :isAjaxResult - def initialize(actionType, eventId, queueId, redirectUrl, redirectType) + def initialize(actionType, eventId, queueId, redirectUrl, redirectType, actionName) @actionType = actionType @eventId = eventId @queueId = queueId @redirectUrl = redirectUrl @redirectType = redirectType + @actionName = actionName end def doRedirect @@ -93,7 +107,7 @@ def getAjaxQueueRedirectHeaderKey def getAjaxRedirectUrl if !Utils.isNilOrEmpty(@redirectUrl) - return CGI.escape(@redirectUrl) + return Utils.urlEncode(@redirectUrl) end return "" end diff --git a/lib/queueit_knownuserv3/queue_url_params.rb b/lib/queueit_knownuserv3/queue_url_params.rb index c0c1749..5997eef 100644 --- a/lib/queueit_knownuserv3/queue_url_params.rb +++ b/lib/queueit_knownuserv3/queue_url_params.rb @@ -4,7 +4,7 @@ class QueueUrlParams KEY_VALUE_SEPARATOR_CHAR = '_' TIMESTAMP_KEY = "ts" COOKIE_VALIDITY_MINUTES_KEY = "cv" - EVENT_ID_KEY = "e"; + EVENT_ID_KEY = "e" EXTENDABLE_COOKIE_KEY = "ce" HASH_KEY = "h" QUEUE_ID_KEY = "q" @@ -33,49 +33,49 @@ def initialize end def self.extractQueueParams(queueitToken) - begin - if(Utils.isNilOrEmpty(queueitToken)) - return nil - end - result = QueueUrlParams.new - result.queueITToken = queueitToken - paramsNameValueList = result.queueITToken.split(KEY_VALUE_SEPARATOR_GROUP_CHAR) + if(Utils.isNilOrEmpty(queueitToken)) + return nil + end + result = QueueUrlParams.new + result.queueITToken = queueitToken + paramsNameValueList = result.queueITToken.split(KEY_VALUE_SEPARATOR_GROUP_CHAR) - paramsNameValueList.each do |pNameValue| - paramNameValueArr = pNameValue.split(KEY_VALUE_SEPARATOR_CHAR) - - case paramNameValueArr[0] - when TIMESTAMP_KEY - begin - result.timeStamp = Integer(paramNameValueArr[1]) - rescue - result.timeStamp = 0 - end - when COOKIE_VALIDITY_MINUTES_KEY - begin - result.cookieValidityMinutes = Integer(paramNameValueArr[1]) - rescue - result.cookieValidityMinutes = nil - end - when EVENT_ID_KEY - result.eventId = paramNameValueArr[1] - when EXTENDABLE_COOKIE_KEY - if paramNameValueArr[1].upcase.eql? 'TRUE' - result.extendableCookie = true - end - when HASH_KEY - result.hashCode = paramNameValueArr[1] - when QUEUE_ID_KEY - result.queueId = paramNameValueArr[1] - when REDIRECT_TYPE_KEY - result.redirectType = paramNameValueArr[1] - end + paramsNameValueList.each do |pNameValue| + paramNameValueArr = pNameValue.split(KEY_VALUE_SEPARATOR_CHAR) + + if(!paramNameValueArr.length().eql? 2) + next end - result.queueITTokenWithoutHash = result.queueITToken.gsub((KEY_VALUE_SEPARATOR_GROUP_CHAR + HASH_KEY + KEY_VALUE_SEPARATOR_CHAR + result.hashCode), "") - return result - rescue - return nil + + case paramNameValueArr[0] + when HASH_KEY + result.hashCode = paramNameValueArr[1] + when TIMESTAMP_KEY + if paramNameValueArr[1] !~ /\D/ + result.timeStamp = paramNameValueArr[1].to_i + else + result.timeStamp = 0 + end + when COOKIE_VALIDITY_MINUTES_KEY + if paramNameValueArr[1] !~ /\D/ + result.cookieValidityMinutes = paramNameValueArr[1].to_i + else + result.cookieValidityMinutes = nil + end + when EVENT_ID_KEY + result.eventId = paramNameValueArr[1] + when EXTENDABLE_COOKIE_KEY + if paramNameValueArr[1].upcase.eql? 'TRUE' + result.extendableCookie = true + end + when QUEUE_ID_KEY + result.queueId = paramNameValueArr[1] + when REDIRECT_TYPE_KEY + result.redirectType = paramNameValueArr[1] + end end + result.queueITTokenWithoutHash = result.queueITToken.gsub((KEY_VALUE_SEPARATOR_GROUP_CHAR + HASH_KEY + KEY_VALUE_SEPARATOR_CHAR + result.hashCode), "") + return result end end -end +end \ No newline at end of file diff --git a/lib/queueit_knownuserv3/user_in_queue_service.rb b/lib/queueit_knownuserv3/user_in_queue_service.rb index 6246c1a..ff4b4d2 100644 --- a/lib/queueit_knownuserv3/user_in_queue_service.rb +++ b/lib/queueit_knownuserv3/user_in_queue_service.rb @@ -3,7 +3,8 @@ module QueueIt class UserInQueueService - SDK_VERSION = "3.5.1" + SDK_VERSION_NO = "3.6.0" + SDK_VERSION = "v3-ruby-" + SDK_VERSION_NO def initialize(userInQueueStateRepository) @userInQueueStateRepository = userInQueueStateRepository @@ -21,14 +22,15 @@ def validateQueueRequest(targetUrl, queueitToken, config, customerId, secretKey) state.redirectType, secretKey) end - return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, state.queueId, nil, state.redirectType) + return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, state.queueId, nil, state.redirectType, config.actionName) end - + queueParams = QueueUrlParams::extractQueueParams(queueitToken) + if(!queueParams.nil?) - return getQueueITTokenValidationResult(targetUrl, config.eventId, config, queueParams, customerId, secretKey) + return getQueueITTokenValidationResult(targetUrl, config, queueParams, customerId, secretKey) else - return getInQueueRedirectResult(targetUrl, config, customerId) + return cancelQueueCookieReturnQueueResult(targetUrl, config, customerId) end end @@ -36,30 +38,27 @@ def validateCancelRequest(targetUrl, cancelConfig, customerId, secretKey) state = @userInQueueStateRepository.getState(cancelConfig.eventId, -1, secretKey, false) if (state.isValid) @userInQueueStateRepository.cancelQueueCookie(cancelConfig.eventId, cancelConfig.cookieDomain) - query = getQueryString(customerId, cancelConfig.eventId, cancelConfig.version, nil, nil) + ( !Utils::isNilOrEmpty(targetUrl) ? ("&r=" + CGI.escape(targetUrl)) : "" ) - - domainAlias = cancelConfig.queueDomain - if (!domainAlias.end_with?("/") ) - domainAlias = domainAlias + "/" - end - - redirectUrl = "https://" + domainAlias + "cancel/" + customerId + "/" + cancelConfig.eventId + "/?" + query - return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, state.queueId, redirectUrl, state.redirectType) + query = getQueryString(customerId, cancelConfig.eventId, cancelConfig.version, cancelConfig.actionName, nil, nil) + + (!Utils::isNilOrEmpty(targetUrl) ? ("&r=" + Utils.urlEncode(targetUrl)) : "" ) + uriPath = "cancel/" + customerId + "/" + cancelConfig.eventId + "/" + + redirectUrl = generateRedirectUrl(cancelConfig.queueDomain, uriPath, query) + return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, state.queueId, redirectUrl, state.redirectType, cancelConfig.actionName) else - return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, nil, nil, nil) + return RequestValidationResult.new(ActionTypes::CANCEL, cancelConfig.eventId, nil, nil, nil, cancelConfig.actionName) end end - def getQueueITTokenValidationResult(targetUrl, eventId, config, queueParams,customerId, secretKey) + def getQueueITTokenValidationResult(targetUrl, config, queueParams,customerId, secretKey) calculatedHash = OpenSSL::HMAC.hexdigest('sha256', secretKey, queueParams.queueITTokenWithoutHash) if (calculatedHash.upcase() != queueParams.hashCode.upcase()) - return getVaidationErrorResult(customerId, targetUrl, config, queueParams, "hash") + return cancelQueueCookieReturnErrorResult(customerId, targetUrl, config, queueParams, "hash") end - if (queueParams.eventId.upcase() != eventId.upcase()) - return getVaidationErrorResult(customerId, targetUrl, config, queueParams, "eventid") + if (queueParams.eventId.upcase() != config.eventId.upcase()) + return cancelQueueCookieReturnErrorResult(customerId, targetUrl, config, queueParams, "eventid") end if (queueParams.timeStamp < Time.now.getutc.tv_sec) - return getVaidationErrorResult(customerId, targetUrl, config, queueParams, "timestamp") + return cancelQueueCookieReturnErrorResult(customerId, targetUrl, config, queueParams, "timestamp") end @userInQueueStateRepository.store( @@ -69,51 +68,63 @@ def getQueueITTokenValidationResult(targetUrl, eventId, config, queueParams,cust !Utils::isNilOrEmpty(config.cookieDomain) ? config.cookieDomain : '', queueParams.redirectType, secretKey) - return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, queueParams.queueId, nil, queueParams.redirectType) + return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, queueParams.queueId, nil, queueParams.redirectType, config.actionName) end - def getVaidationErrorResult(customerId, targetUrl, config, qParams, errorCode) - query = getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName) + + def cancelQueueCookieReturnErrorResult(customerId, targetUrl, config, qParams, errorCode) + @userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain) + + query = getQueryString(customerId, config.eventId, config.version, config.actionName, config.culture, config.layoutName) + "&queueittoken=" + qParams.queueITToken + "&ts=" + Time.now.getutc.tv_sec.to_s + - (!Utils::isNilOrEmpty(targetUrl) ? ("&t=" + CGI.escape(targetUrl)) : "") - domainAlias = config.queueDomain - if (!domainAlias.end_with?("/") ) - domainAlias = domainAlias + "/" - end - redirectUrl = "https://" + domainAlias + "error/" + errorCode + "/?" + query - return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl, nil) + (!Utils::isNilOrEmpty(targetUrl) ? ("&t=" + Utils.urlEncode(targetUrl)) : "") + + redirectUrl = generateRedirectUrl(config.queueDomain, "error/" + errorCode + "/", query) + + return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl, nil, config.actionName) end - def getInQueueRedirectResult(targetUrl, config, customerId) - redirectUrl = "https://" + config.queueDomain + - "?" + getQueryString(customerId, config.eventId, config.version, config.culture, config.layoutName) + - (!Utils::isNilOrEmpty(targetUrl) ? "&t=" + - CGI.escape( targetUrl) : "") - return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl, nil) + def cancelQueueCookieReturnQueueResult(targetUrl, config, customerId) + @userInQueueStateRepository.cancelQueueCookie(config.eventId, config.cookieDomain) + + query = getQueryString(customerId, config.eventId, config.version, config.actionName, config.culture, config.layoutName) + + (!Utils::isNilOrEmpty(targetUrl) ? "&t=" + Utils.urlEncode( targetUrl) : "") + + redirectUrl = generateRedirectUrl(config.queueDomain, "", query) + + return RequestValidationResult.new(ActionTypes::QUEUE, config.eventId, nil, redirectUrl, nil, config.actionName) end - def getQueryString(customerId, eventId, configVersion, culture, layoutName) + def getQueryString(customerId, eventId, configVersion, actionName, culture, layoutName) queryStringList = Array.new - queryStringList.push("c=" + CGI.escape(customerId)) - queryStringList.push("e=" + CGI.escape(eventId)) - queryStringList.push("ver=v3-ruby-" + SDK_VERSION) + queryStringList.push("c=" + Utils.urlEncode(customerId)) + queryStringList.push("e=" + Utils.urlEncode(eventId)) + queryStringList.push("ver=" + SDK_VERSION) queryStringList.push("cver=" + (!configVersion.nil? ? configVersion.to_s : '-1')) + queryStringList.push("man=" + Utils.urlEncode(actionName)) + if (!Utils::isNilOrEmpty(culture)) - queryStringList.push("cid=" + CGI.escape(culture)) + queryStringList.push("cid=" + Utils.urlEncode(culture)) end if (!Utils::isNilOrEmpty(layoutName)) - queryStringList.push("l=" + CGI.escape(layoutName)) + queryStringList.push("l=" + Utils.urlEncode(layoutName)) end return queryStringList.join("&") end + def generateRedirectUrl(queueDomain, uriPath, query) + if (!queueDomain.end_with?("/") ) + queueDomain = queueDomain + "/" + end + return "https://" + queueDomain + uriPath + "?" + query + end + def extendQueueCookie(eventId, cookieValidityMinutes, cookieDomain, secretKey) @userInQueueStateRepository.reissueQueueCookie(eventId, cookieValidityMinutes, cookieDomain, secretKey) end - def getIgnoreActionResult() - return RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil, nil) + def getIgnoreActionResult(actionName) + return RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil, nil, actionName) end end end diff --git a/lib/queueit_knownuserv3/user_in_queue_state_cookie_repository.rb b/lib/queueit_knownuserv3/user_in_queue_state_cookie_repository.rb index b5fea24..6e40e72 100644 --- a/lib/queueit_knownuserv3/user_in_queue_state_cookie_repository.rb +++ b/lib/queueit_knownuserv3/user_in_queue_state_cookie_repository.rb @@ -182,4 +182,4 @@ def isStateExtendable return @isValid && @fixedCookieValidityMinutes.nil? end end -end +end \ No newline at end of file diff --git a/queueit_knownuserv3.gemspec b/queueit_knownuserv3.gemspec index 20edc18..44546b5 100644 --- a/queueit_knownuserv3.gemspec +++ b/queueit_knownuserv3.gemspec @@ -5,7 +5,7 @@ require 'queueit_knownuserv3/user_in_queue_service' Gem::Specification.new do |spec| spec.name = "queueit_knownuserv3" - spec.version = QueueIt::UserInQueueService::SDK_VERSION + spec.version = QueueIt::UserInQueueService::SDK_VERSION_NO spec.authors = ["Queue-it"] spec.email = ["support@queue-it.com"] spec.licenses = "LGPL-3.0" @@ -25,7 +25,4 @@ Gem::Specification.new do |spec| spec.bindir = "exe" spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) } spec.require_paths = ["lib"] - - spec.add_development_dependency "bundler", "~> 1.11" - spec.add_development_dependency "rake", "~> 10.0" end diff --git a/test/queueit_knownuserv3/test_integration_config_helpers.rb b/test/queueit_knownuserv3/test_integration_config_helpers.rb index a0cbba8..cdfd75d 100644 --- a/test/queueit_knownuserv3/test_integration_config_helpers.rb +++ b/test/queueit_knownuserv3/test_integration_config_helpers.rb @@ -562,30 +562,6 @@ def test_evaluate_contains_operator assert( ComparisonOperatorHelper.evaluate("Contains", false, false, "test_dsdsdsdtest1", "*", nil) ) end - def test_evaluate_startsWith_operator - assert( ComparisonOperatorHelper.evaluate("StartsWith", false, false, nil, nil, nil) ) - assert( ComparisonOperatorHelper.evaluate("StartsWith", false, false, "test1_test1_test", "test1", nil) ) - assert( !ComparisonOperatorHelper.evaluate("StartsWith", false, false, "test1_test1_test", "Test1", nil) ) - assert( ComparisonOperatorHelper.evaluate("StartsWith", false, true, "test1_test1_test", "Test1", nil) ) - assert( !ComparisonOperatorHelper.evaluate("StartsWith", true, true, "test1_test1_test", "Test1", nil) ) - end - - def test_evaluate_endsWith_operator - assert( ComparisonOperatorHelper.evaluate("EndsWith", false, false, nil, nil, nil) ) - assert( ComparisonOperatorHelper.evaluate("EndsWith", false, false, "test1_test1_testshop", "shop", nil) ) - assert( !ComparisonOperatorHelper.evaluate("EndsWith", false, false, "test1_test1_testshop2", "shop", nil) ) - assert( ComparisonOperatorHelper.evaluate("EndsWith", false, true, "test1_test1_testshop", "Shop", nil) ) - assert( !ComparisonOperatorHelper.evaluate("EndsWith", true, true, "test1_test1_testshop", "Shop", nil) ) - end - - def test_evaluate_matchesWith_operator - assert( ComparisonOperatorHelper.evaluate("MatchesWith", false, false, nil, nil, nil) ) - assert( ComparisonOperatorHelper.evaluate("MatchesWith", false, false, "test1_test1_testshop", ".*shop.*", nil) ) - assert( !ComparisonOperatorHelper.evaluate("MatchesWith", false, false, "test1_test1_testshop2", ".*Shop.*", nil) ) - assert( ComparisonOperatorHelper.evaluate("MatchesWith", false, true, "test1_test1_testshop", ".*Shop.*", nil) ) - assert( !ComparisonOperatorHelper.evaluate("MatchesWith", true, true, "test1_test1_testshop", ".*Shop.*", nil) ) - end - def test_evaluate_equalsAny_operator assert( ComparisonOperatorHelper.evaluate("EqualsAny", false, false, "test1", nil, ["test1"]) ) assert( !ComparisonOperatorHelper.evaluate("EqualsAny", false, false, "test1", nil, ["Test1"]) ) diff --git a/test/queueit_knownuserv3/test_known_user.rb b/test/queueit_knownuserv3/test_known_user.rb index d2a258e..572dc89 100644 --- a/test/queueit_knownuserv3/test_known_user.rb +++ b/test/queueit_knownuserv3/test_known_user.rb @@ -25,20 +25,24 @@ class UserInQueueServiceMock attr_reader :extendQueueCookieCalls attr_reader :validateQueueRequestCalls attr_reader :validateCancelRequestCalls - attr_reader :getIgnoreActionResultCalls + attr_reader :getIgnoreActionResultCalls attr_accessor :validateQueueRequestResult attr_accessor :validateCancelRequestResult attr_accessor :getIgnoreActionResult + attr_accessor :validateCancelRequestRaiseException + attr_accessor :validateQueueRequestRaiseException def initialize @extendQueueCookieCalls = {} @validateQueueRequestCalls = {} @validateCancelRequestCalls = {} @getIgnoreActionResultCalls = {} - @validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, nil, nil, nil, nil) - @validateCancelRequestResult = RequestValidationResult.new(ActionTypes::CANCEL, nil, nil, nil, nil) - @getIgnoreActionResult = RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil, nil) + @validateCancelRequestRaiseException = false + @validateQueueRequestRaiseException = false + @validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, nil, nil, nil, nil, nil) + @validateCancelRequestResult = RequestValidationResult.new(ActionTypes::CANCEL, nil, nil, nil, nil, nil) + @getIgnoreActionResult = RequestValidationResult.new(ActionTypes::IGNORE, nil, nil, nil, nil, nil) end def extendQueueCookie(eventId, cookieValidityMinute, cookieDomain, secretKey) @@ -58,6 +62,11 @@ def validateQueueRequest(targetUrl, queueitToken, config, customerId, secretKey) "customerId" => customerId, "secretKey" => secretKey } + + if(@validateQueueRequestRaiseException) + raise Exception.new, "Exception" + end + return @validateQueueRequestResult end @@ -68,18 +77,31 @@ def validateCancelRequest(targetUrl, config, customerId, secretKey) "customerId" => customerId, "secretKey" => secretKey } + + if(@validateCancelRequestRaiseException) + raise Exception.new, "Exception" + end return @validateCancelRequestResult end - def getIgnoreActionResult() - @getIgnoreActionResultCalls[@getIgnoreActionResultCalls.length] = {} + def getIgnoreActionResult(actionName) + @getIgnoreActionResultCalls[@getIgnoreActionResultCalls.length] = {"actionName" => actionName} return @getIgnoreActionResult end end class QueueITTokenGenerator - def self.generateDebugToken(eventId, secretKey) - tokenWithoutHash = (QueueUrlParams::EVENT_ID_KEY + QueueUrlParams::KEY_VALUE_SEPARATOR_CHAR + eventId) + QueueUrlParams::KEY_VALUE_SEPARATOR_GROUP_CHAR + (QueueUrlParams::REDIRECT_TYPE_KEY + QueueUrlParams::KEY_VALUE_SEPARATOR_CHAR + "debug") + def self.generateDebugToken(eventId, secretKey, expired) + ts = (Time.now.getutc.tv_sec + 1000).to_s + if(expired) + ts = (Time.now.getutc.tv_sec - 1000).to_s + end + tokenWithoutHash = QueueUrlParams::EVENT_ID_KEY + QueueUrlParams::KEY_VALUE_SEPARATOR_CHAR + eventId + + QueueUrlParams::KEY_VALUE_SEPARATOR_GROUP_CHAR + + QueueUrlParams::REDIRECT_TYPE_KEY + QueueUrlParams::KEY_VALUE_SEPARATOR_CHAR + "debug" + + QueueUrlParams::KEY_VALUE_SEPARATOR_GROUP_CHAR + + QueueUrlParams::TIMESTAMP_KEY + QueueUrlParams::KEY_VALUE_SEPARATOR_CHAR + ts + hash = OpenSSL::HMAC.hexdigest('sha256', secretKey, tokenWithoutHash) token = tokenWithoutHash + QueueUrlParams::KEY_VALUE_SEPARATOR_GROUP_CHAR + QueueUrlParams::HASH_KEY + QueueUrlParams::KEY_VALUE_SEPARATOR_CHAR + hash return token @@ -96,6 +118,7 @@ def test_cancelRequestByLocalConfig cancelConfig.queueDomain = "queueDomain" cancelConfig.version = 1 cancelConfig.cookieDomain = "cookieDomain" + cancelConfig.actionName = "CancelAction" result = KnownUser.cancelRequestByLocalConfig("targetUrl", "token", cancelConfig, "customerId", "secretKey", HttpRequestMock.new) @@ -115,10 +138,11 @@ def test_cancelRequestByLocalConfig_AjaxCall cancelConfig.queueDomain = "queueDomain" cancelConfig.version = 1 cancelConfig.cookieDomain = "cookieDomain" + cancelConfig.actionName = "CancelAction" requestMock = HttpRequestMock.new requestMock.headers = { "x-queueit-ajaxpageurl" => "http%3a%2f%2furl" } - userInQueueService.validateCancelRequestResult = RequestValidationResult.new(ActionTypes::CANCEL, "eventId", nil, "http://q.qeuue-it.com", nil) + userInQueueService.validateCancelRequestResult = RequestValidationResult.new(ActionTypes::CANCEL, "eventId", nil, "http://q.qeuue-it.com", nil, cancelConfig.actionName) result = KnownUser.cancelRequestByLocalConfig("targetUrl", "token", cancelConfig, "customerId", "secretKey", requestMock) @@ -128,51 +152,7 @@ def test_cancelRequestByLocalConfig_AjaxCall assert( userInQueueService.validateCancelRequestCalls[0]["secretKey"] == "secretKey" ) assert( result.isAjaxResult ) assert( result.getAjaxRedirectUrl.downcase == "http%3a%2f%2fq.qeuue-it.com" ) - end - - def test_cancelRequestByLocalConfig_setDebugCookie - userInQueueService = UserInQueueServiceMock.new - KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) - - cancelConfig = CancelEventConfig.new - cancelConfig.eventId = "eventId" - cancelConfig.queueDomain = "queueDomain" - cancelConfig.version = 1 - cancelConfig.cookieDomain = "cookieDomain" - - requestMock = HttpRequestMock.new - requestMock.setRealOriginalUrl("http", "localhost", "/original_url") - requestMock.cookie_jar = {} - requestMock.remote_ip = "userIP" - requestMock.headers = { - "via" => "v", - "forwarded" => "f", - "x-forwarded-for" => "xff", - "x-forwarded-host" => "xfh", - "x-forwarded-proto" => "xfp" } - - secretKey = "secretKey" - queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", secretKey) - - expectedServerTime = Time.now.utc.iso8601 - KnownUser.cancelRequestByLocalConfig("url", queueitToken, cancelConfig, "customerId", secretKey, requestMock) - - expectedCookieValue = "TargetUrl=url|QueueitToken=" + queueitToken + - "|OriginalUrl=http://localhost/original_url" + - "|CancelConfig=EventId:eventId&Version:1&QueueDomain:queueDomain&CookieDomain:cookieDomain" + - "|ServerUtcTime=" + expectedServerTime + - "|RequestIP=userIP" + - "|RequestHttpHeader_Via=v" + - "|RequestHttpHeader_Forwarded=f" + - "|RequestHttpHeader_XForwardedFor=xff" + - "|RequestHttpHeader_XForwardedHost=xfh" + - "|RequestHttpHeader_XForwardedProto=xfp" - - assert( requestMock.cookie_jar.length == 1 ); - assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) - - actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] - assert( expectedCookieValue.eql?(actualCookieValue) ) + assert( result.actionName == cancelConfig.actionName ) end def test_cancelRequestByLocalConfig_nil_QueueDomain @@ -467,54 +447,6 @@ def test_resolveQueueRequestByLocalConfig_zero_cookieValidityMinute assert( errorThrown ) end - def test_resolveQueueRequestByLocalConfig_setDebugCookie - userInQueueService = UserInQueueServiceMock.new - KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) - - queueConfig = QueueEventConfig.new - queueConfig.cookieDomain = "cookieDomain" - queueConfig.layoutName = "layoutName" - queueConfig.culture = "culture" - queueConfig.eventId = "eventId" - queueConfig.queueDomain = "queueDomain" - queueConfig.extendCookieValidity = true - queueConfig.cookieValidityMinute = 10 - queueConfig.version = 12 - - requestMock = HttpRequestMock.new - requestMock.setRealOriginalUrl("http", "localhost", "/original_url") - requestMock.cookie_jar = {} - requestMock.remote_ip = "userIP" - requestMock.headers = { - "via" => "v", - "forwarded" => "f", - "x-forwarded-for" => "xff", - "x-forwarded-host" => "xfh", - "x-forwarded-proto" => "xfp" } - - secretKey = "secretKey" - queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", secretKey) - - expectedServerTime = Time.now.utc.iso8601 - KnownUser.resolveQueueRequestByLocalConfig("url", queueitToken, queueConfig, "customerId", secretKey, requestMock) - - expectedCookieValue = "TargetUrl=url|QueueitToken=" + queueitToken + - "|OriginalUrl=http://localhost/original_url" + - "|QueueConfig=EventId:eventId&Version:12&QueueDomain:queueDomain&CookieDomain:cookieDomain&ExtendCookieValidity:true&CookieValidityMinute:10&LayoutName:layoutName&Culture:culture" + - "|ServerUtcTime=" + expectedServerTime + - "|RequestIP=userIP" + - "|RequestHttpHeader_Via=v" + - "|RequestHttpHeader_Forwarded=f" + - "|RequestHttpHeader_XForwardedFor=xff" + - "|RequestHttpHeader_XForwardedHost=xfh" + - "|RequestHttpHeader_XForwardedProto=xfp" - - assert( requestMock.cookie_jar.length == 1 ); - assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) - actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] - assert( expectedCookieValue.eql?(actualCookieValue) ) - end - def test_resolveQueueRequestByLocalConfig userInQueueService = UserInQueueServiceMock.new KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) @@ -528,6 +460,7 @@ def test_resolveQueueRequestByLocalConfig queueConfig.extendCookieValidity = true queueConfig.cookieValidityMinute = 10 queueConfig.version = 12 + queueConfig.actionName = "QueueAction" result = KnownUser.resolveQueueRequestByLocalConfig("target", "token", queueConfig, "id", "key", HttpRequestMock.new) @@ -552,10 +485,11 @@ def test_resolveQueueRequestByLocalConfig_AjaxCall queueConfig.extendCookieValidity = true queueConfig.cookieValidityMinute = 10 queueConfig.version = 12 + queueConfig.actionName = "QueueAction" requestMock = HttpRequestMock.new requestMock.headers = { "x-queueit-ajaxpageurl" => "http%3a%2f%2furl" } - userInQueueService.validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, "eventId", nil, "http://q.qeuue-it.com", nil) + userInQueueService.validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, "eventId", nil, "http://q.qeuue-it.com", nil, queueConfig.actionName) result = KnownUser.resolveQueueRequestByLocalConfig("targetUrl", "token", queueConfig, "customerId", "secretKey", requestMock) @@ -565,13 +499,14 @@ def test_resolveQueueRequestByLocalConfig_AjaxCall assert( userInQueueService.validateQueueRequestCalls[0]["secretKey"] == "secretKey" ) assert( result.isAjaxResult ) assert( result.getAjaxRedirectUrl.downcase == "http%3a%2f%2fq.qeuue-it.com" ) + assert( result.actionName == queueConfig.actionName ) end def test_validateRequestByIntegrationConfig_empty_currentUrlWithoutQueueITToken errorThrown = false begin - KnownUser.validateRequestByIntegrationConfig("", "queueIttoken", nil, "customerId", "secretKey", HttpRequestMock.new) + KnownUser.validateRequestByIntegrationConfig("", "queueIttoken", "{}", "customerId", "secretKey", HttpRequestMock.new) rescue KnownUserError => err errorThrown = err.message.start_with? "currentUrlWithoutQueueITToken can not be nil or empty" end @@ -579,30 +514,6 @@ def test_validateRequestByIntegrationConfig_empty_currentUrlWithoutQueueITToken assert( errorThrown ) end - def test_validateRequestByIntegrationConfig_empty_integrationsConfigString - errorThrown = false - - begin - KnownUser.validateRequestByIntegrationConfig("currentUrlWithoutQueueITToken", "queueIttoken", nil, "customerId", "secretKey", HttpRequestMock.new) - rescue KnownUserError => err - errorThrown = err.message.start_with? "integrationsConfigString can not be nil or empty" - end - - assert( errorThrown ) - end - - def test_validateRequestByIntegrationConfig_invalid_integrationsConfigString - errorThrown = false - - begin - KnownUser.validateRequestByIntegrationConfig("currentUrlWithoutQueueITToken", "queueIttoken", "not-valid-json", "customerId", "secretKey", HttpRequestMock.new) - rescue KnownUserError => err - errorThrown = err.message.start_with? "integrationConfiguration text was not valid" - end - - assert( errorThrown ) - end - def test_validateRequestByIntegrationConfig userInQueueService = UserInQueueServiceMock.new KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) @@ -674,6 +585,7 @@ def test_validateRequestByIntegrationConfig assert( userInQueueService.validateQueueRequestCalls[0]["config"].cookieValidityMinute == 20 ) assert( userInQueueService.validateQueueRequestCalls[0]["config"].cookieDomain == ".test.com" ) assert( userInQueueService.validateQueueRequestCalls[0]["config"].version == 3 ) + assert( userInQueueService.validateQueueRequestCalls[0]["config"].actionName == integrationConfig[:Integrations][0][:Name] ) assert( !result.isAjaxResult ) end @@ -735,7 +647,7 @@ def test_validateRequestByIntegrationConfig_AjaxCall mockRequest.cookie_jar = Hash.new integrationConfigJson = JSON.generate(integrationConfig) - userInQueueService.validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, "eventId", nil, "http://q.qeuue-it.com", nil) + userInQueueService.validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, "eventId", nil, "http://q.qeuue-it.com", nil, integrationConfig[:Integrations][0][:Name]) result = KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "token", integrationConfigJson, "id", "key", mockRequest) @@ -752,99 +664,10 @@ def test_validateRequestByIntegrationConfig_AjaxCall assert( userInQueueService.validateQueueRequestCalls[0]["config"].cookieValidityMinute == 20 ) assert( userInQueueService.validateQueueRequestCalls[0]["config"].cookieDomain == ".test.com" ) assert( userInQueueService.validateQueueRequestCalls[0]["config"].version == 3 ) + assert( userInQueueService.validateQueueRequestCalls[0]["config"].actionName == integrationConfig[:Integrations][0][:Name] ) assert( result.isAjaxResult ) assert( result.getAjaxRedirectUrl.downcase == "http%3a%2f%2fq.qeuue-it.com" ) - end - - def test_validateRequestByIntegrationConfig_setDebugCookie - userInQueueService = UserInQueueServiceMock.new - KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) - - integrationConfig = - { - :Description => "test", - :Integrations => - [ - { - :Name => "event1action", - #:ActionType => "Queue", #omitting will default to "Queue" - :EventId => "event1", - :CookieDomain => ".test.com", - :LayoutName => "Christmas Layout by Queue-it", - :Culture => "da-DK", - :ExtendCookieValidity => true, - :CookieValidityMinute => 20, - :Triggers => - [ - { - :TriggerParts => - [ - { - :Operator => "Contains", - :ValueToCompare => "event1", - :UrlPart => "PageUrl", - :ValidatorType => "UrlValidator", - :IsNegative => false, - :IsIgnoreCase => true - }, - { - :Operator => "Contains", - :ValueToCompare => "googlebot", - :ValidatorType => "UserAgentValidator", - :IsNegative => false, - :IsIgnoreCase => false - } - ], - :LogicalOperator => "And" - } - ], - :QueueDomain => "knownusertest.queue-it.net", - :RedirectLogic => "AllowTParameter" - } - ], - :CustomerId => "knownusertest", - :AccountId => "knownusertest", - :Version => 3, - :PublishDate => "2017-05-15T21:39:12.0076806Z", - :ConfigDataVersion => "1.0.0.1" - } - - requestMock = HttpRequestMock.new - requestMock.user_agent = "googlebot" - requestMock.setRealOriginalUrl("http", "localhost", "/original_url") - requestMock.cookie_jar = {} - requestMock.remote_ip = "userIP" - requestMock.headers = { - "via" => "v", - "forwarded" => "f", - "x-forwarded-for" => "xff", - "x-forwarded-host" => "xfh", - "x-forwarded-proto" => "xfp" } - integrationConfigJson = JSON.generate(integrationConfig) - - secretKey = "secretKey" - queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", secretKey) - - expectedServerTime = Time.now.utc.iso8601 - KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", queueitToken, integrationConfigJson, "customerId", secretKey, requestMock) - - expectedCookieValue = "ConfigVersion=3|PureUrl=http://test.com?event1=true|QueueitToken=" + queueitToken + - "|OriginalUrl=http://localhost/original_url" + - "|ServerUtcTime=" + expectedServerTime + - "|RequestIP=userIP" + - "|RequestHttpHeader_Via=v" + - "|RequestHttpHeader_Forwarded=f" + - "|RequestHttpHeader_XForwardedFor=xff" + - "|RequestHttpHeader_XForwardedHost=xfh" + - "|RequestHttpHeader_XForwardedProto=xfp" + - "|MatchedConfig=event1action|TargetUrl=http://test.com?event1=true|QueueConfig=EventId:event1&Version:3&QueueDomain:knownusertest.queue-it.net&CookieDomain:.test.com&ExtendCookieValidity:true&CookieValidityMinute:20&LayoutName:Christmas Layout by Queue-it&Culture:da-DK" - - assert( requestMock.cookie_jar.length == 1 ); - assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) - - actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] - assert( expectedCookieValue.eql?(actualCookieValue) ) - end + end def test_validateRequestByIntegrationConfig_NotMatch userInQueueService = UserInQueueServiceMock.new @@ -868,57 +691,7 @@ def test_validateRequestByIntegrationConfig_NotMatch assert( userInQueueService.validateQueueRequestCalls.length == 0 ) assert( !result.doRedirect ) end - - def test_validateRequestByIntegrationConfig_setDebugCookie_NotMatch - userInQueueService = UserInQueueServiceMock.new - KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) - - requestMock = HttpRequestMock.new - requestMock.setRealOriginalUrl("http", "localhost", "/original_url") - requestMock.cookie_jar = {} - requestMock.remote_ip = "userIP" - requestMock.headers = { - "via" => "v", - "forwarded" => "f", - "x-forwarded-for" => "xff", - "x-forwarded-host" => "xfh", - "x-forwarded-proto" => "xfp" } - integrationConfig = - { - :Description => "test", - :Integrations => [ - ], - :CustomerId => "knownusertest", - :AccountId => "knownusertest", - :Version => 3, - :PublishDate => "2017-05-15T21:39:12.0076806Z", - :ConfigDataVersion => "1.0.0.1" - } - - secretKey = "secretKey" - queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", secretKey) - - integrationConfigJson = JSON.generate(integrationConfig) - expectedServerTime = Time.now.utc.iso8601 - KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", queueitToken, integrationConfigJson, "customerId", secretKey, requestMock) - - expectedCookieValue = "ConfigVersion=3|PureUrl=http://test.com?event1=true|QueueitToken=" + queueitToken + - "|OriginalUrl=http://localhost/original_url" + - "|ServerUtcTime=" + expectedServerTime + - "|RequestIP=userIP" + - "|RequestHttpHeader_Via=v" + - "|RequestHttpHeader_Forwarded=f" + - "|RequestHttpHeader_XForwardedFor=xff" + - "|RequestHttpHeader_XForwardedHost=xfh" + - "|RequestHttpHeader_XForwardedProto=xfp" + - "|MatchedConfig=NULL" - - assert( requestMock.cookie_jar.length == 1 ); - assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) - actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] - assert( expectedCookieValue.eql?(actualCookieValue) ) - end def test_validateRequestByIntegrationConfig_ForcedTargetUrl userInQueueService = UserInQueueServiceMock.new @@ -1023,7 +796,7 @@ def test_validateRequestByIntegrationConfig_ForcedTargetUrl_AjaxCall requestMock = HttpRequestMock.new requestMock.headers = { "x-queueit-ajaxpageurl" => "http%3a%2f%2furl" } - userInQueueService.validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, "eventId", nil, "http://q.qeuue-it.com", nil) + userInQueueService.validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, "eventId", nil, "http://q.qeuue-it.com", nil, integrationConfig[:Integrations][0][:Name]) integrationConfigJson = JSON.generate(integrationConfig) result = KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueIttoken", integrationConfigJson, "customerid", "secretkey", requestMock) @@ -1134,7 +907,7 @@ def test_validateRequestByIntegrationConfig_EventTargetUrl_AjaxCall requestMock = HttpRequestMock.new requestMock.headers = { "x-queueit-ajaxpageurl" => "http%3a%2f%2furl" } - userInQueueService.validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, "eventId", nil, "http://q.qeuue-it.com", nil) + userInQueueService.validateQueueRequestResult = RequestValidationResult.new(ActionTypes::QUEUE, "eventId", nil, "http://q.qeuue-it.com", nil, integrationConfig[:Integrations][0][:Name]) integrationConfigJson = JSON.generate(integrationConfig) result = KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueIttoken", integrationConfigJson, "customerid", "secretkey", requestMock) @@ -1196,6 +969,7 @@ def test_validateRequestByIntegrationConfig_CancelAction assert( userInQueueService.validateCancelRequestCalls[0]["config"].eventId == "event1" ) assert( userInQueueService.validateCancelRequestCalls[0]["config"].cookieDomain == ".test.com" ) assert( userInQueueService.validateCancelRequestCalls[0]["config"].version == 3 ) + assert( userInQueueService.validateCancelRequestCalls[0]["config"].actionName == integrationConfig[:Integrations][0][:Name] ) assert( !result.isAjaxResult ) end @@ -1242,10 +1016,10 @@ def test_validateRequestByIntegrationConfig_CancelAction_AjaxCall requestMock = HttpRequestMock.new requestMock.headers = { "x-queueit-ajaxpageurl" => "http%3a%2f%2furl" } - userInQueueService.validateCancelRequestResult = RequestValidationResult.new(ActionTypes::CANCEL, "eventId", nil, "http://q.qeuue-it.com", nil) + userInQueueService.validateCancelRequestResult = RequestValidationResult.new(ActionTypes::CANCEL, "eventId", nil, "http://q.qeuue-it.com", nil, integrationConfig[:Integrations][0][:Name]) integrationConfigJson = JSON.generate(integrationConfig) - result = KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueIttoken", integrationConfigJson, "customerid", "secretkey", requestMock) + result = KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueIttoken", integrationConfigJson, "customerid", "secretkey", requestMock) assert( userInQueueService.validateCancelRequestCalls[0]["targetUrl"] == "http://url" ) assert( userInQueueService.validateCancelRequestCalls[0]["customerId"] == "customerid" ) @@ -1255,6 +1029,7 @@ def test_validateRequestByIntegrationConfig_CancelAction_AjaxCall assert( userInQueueService.validateCancelRequestCalls[0]["config"].eventId == "event1" ) assert( userInQueueService.validateCancelRequestCalls[0]["config"].cookieDomain == ".test.com" ) assert( userInQueueService.validateCancelRequestCalls[0]["config"].version == 3 ) + assert( userInQueueService.validateCancelRequestCalls[0]["config"].actionName == integrationConfig[:Integrations][0][:Name] ) assert( result.isAjaxResult ) assert( result.getAjaxRedirectUrl.downcase == "http%3a%2f%2fq.qeuue-it.com" ) end @@ -1304,6 +1079,7 @@ def test_validateRequestByIntegrationConfig_ignoreAction result = KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueIttoken", integrationConfigJson, "customerid", "secretkey", HttpRequestMock.new) assert( userInQueueService.getIgnoreActionResultCalls.length.eql? 1 ) + assert( userInQueueService.getIgnoreActionResultCalls[0]["actionName"] == integrationConfig[:Integrations][0][:Name] ) assert( !result.isAjaxResult ) end @@ -1355,6 +1131,7 @@ def test_validateRequestByIntegrationConfig_ignoreAction_AjaxCall result = KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueIttoken", integrationConfigJson, "customerid", "secretkey", requestMock) assert( userInQueueService.getIgnoreActionResultCalls.length.eql? 1 ) + assert( userInQueueService.getIgnoreActionResultCalls[0]["actionName"] == integrationConfig[:Integrations][0][:Name] ) assert( result.isAjaxResult ) end @@ -1403,6 +1180,714 @@ def test_validateRequestByIntegrationConfig_defaultsTo_ignoreAction KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueIttoken", integrationConfigJson, "customerid", "secretkey", HttpRequestMock.new) assert( userInQueueService.getIgnoreActionResultCalls.length.eql? 1 ) + assert( userInQueueService.getIgnoreActionResultCalls[0]["actionName"] == integrationConfig[:Integrations][0][:Name] ) + end + + def test_ValidateRequestByIntegrationConfig_Debug + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + integrationConfig = + { + :Description => "test", + :Integrations => + [ + { + :Name => "event1action", + #:ActionType => "Queue", #omitting will default to "Queue" + :EventId => "event1", + :CookieDomain => ".test.com", + :LayoutName => "Christmas Layout by Queue-it", + :Culture => "da-DK", + :ExtendCookieValidity => true, + :CookieValidityMinute => 20, + :Triggers => + [ + { + :TriggerParts => + [ + { + :Operator => "Contains", + :ValueToCompare => "event1", + :UrlPart => "PageUrl", + :ValidatorType => "UrlValidator", + :IsNegative => false, + :IsIgnoreCase => true + }, + { + :Operator => "Contains", + :ValueToCompare => "googlebot", + :ValidatorType => "UserAgentValidator", + :IsNegative => false, + :IsIgnoreCase => false + } + ], + :LogicalOperator => "And" + } + ], + :QueueDomain => "knownusertest.queue-it.net", + :RedirectLogic => "AllowTParameter" + } + ], + :CustomerId => "knownusertest", + :AccountId => "knownusertest", + :Version => 3, + :PublishDate => "2017-05-15T21:39:12.0076806Z", + :ConfigDataVersion => "1.0.0.1" + } + + requestMock = HttpRequestMock.new + requestMock.user_agent = "googlebot" + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + integrationConfigJson = JSON.generate(integrationConfig) + + secretKey = "secretKey" + queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", secretKey, false) + + expectedServerTime = Time.now.utc.iso8601 + KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", queueitToken, integrationConfigJson, "customerId", secretKey, requestMock) + + expectedCookieValue = + "SdkVersion=" + UserInQueueService::SDK_VERSION + + "|Runtime=" + RUBY_VERSION.to_s + + "|PureUrl=http://test.com?event1=true|QueueitToken=" + queueitToken + + "|OriginalUrl=http://localhost/original_url" + + "|ServerUtcTime=" + expectedServerTime + + "|RequestIP=userIP" + + "|RequestHttpHeader_Via=v" + + "|RequestHttpHeader_Forwarded=f" + + "|RequestHttpHeader_XForwardedFor=xff" + + "|RequestHttpHeader_XForwardedHost=xfh" + + "|RequestHttpHeader_XForwardedProto=xfp" + + "|ConfigVersion=3|MatchedConfig=event1action" + + "|TargetUrl=http://test.com?event1=true|QueueConfig=EventId:event1&Version:3&QueueDomain:knownusertest.queue-it.net&CookieDomain:.test.com&ExtendCookieValidity:true&CookieValidityMinute:20&LayoutName:Christmas Layout by Queue-it&Culture:da-DK&ActionName:" + integrationConfig[:Integrations][0][:Name] + + assert( requestMock.cookie_jar.length == 1 ) + assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) + + actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] + assert( expectedCookieValue.eql?(actualCookieValue) ) + end + + def test_ValidateRequestByIntegrationConfig_Debug_WithoutMatch + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + + integrationConfig = + { + :Description => "test", + :Integrations => [ + ], + :CustomerId => "knownusertest", + :AccountId => "knownusertest", + :Version => 3, + :PublishDate => "2017-05-15T21:39:12.0076806Z", + :ConfigDataVersion => "1.0.0.1" + } + + secretKey = "secretKey" + queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", secretKey, false) + + integrationConfigJson = JSON.generate(integrationConfig) + expectedServerTime = Time.now.utc.iso8601 + KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", queueitToken, integrationConfigJson, "customerId", secretKey, requestMock) + + expectedCookieValue = + "SdkVersion=" + UserInQueueService::SDK_VERSION + + "|Runtime=" + RUBY_VERSION.to_s + + "|PureUrl=http://test.com?event1=true|QueueitToken=" + queueitToken + + "|OriginalUrl=http://localhost/original_url" + + "|ServerUtcTime=" + expectedServerTime + + "|RequestIP=userIP" + + "|RequestHttpHeader_Via=v" + + "|RequestHttpHeader_Forwarded=f" + + "|RequestHttpHeader_XForwardedFor=xff" + + "|RequestHttpHeader_XForwardedHost=xfh" + + "|RequestHttpHeader_XForwardedProto=xfp" + + "|ConfigVersion=3|MatchedConfig=NULL" + + assert( requestMock.cookie_jar.length == 1 ) + assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) + actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] + assert( expectedCookieValue.eql?(actualCookieValue) ) + end + + def test_validateRequestByIntegrationConfig_debug_invalid_config_json + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + + integrationConfigJson = "{}" + queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", false) + + expectedServerTime = Time.now.utc.iso8601 + + errorThrown = false + begin + KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", queueitToken, + integrationConfigJson, "customerId", "secretKey", requestMock) + rescue KnownUserError => err + errorThrown = err.message.start_with? "integrationConfigJson is not valid json." + end + + assert( errorThrown ) + + expectedCookieValue = + "SdkVersion=" + UserInQueueService::SDK_VERSION + + "|Runtime=" + RUBY_VERSION.to_s + + "|PureUrl=http://test.com?event1=true" + + "|QueueitToken=" + queueitToken + + "|OriginalUrl=http://localhost/original_url" + + "|ServerUtcTime=" + expectedServerTime + + "|RequestIP=userIP" + + "|RequestHttpHeader_Via=v" + + "|RequestHttpHeader_Forwarded=f" + + "|RequestHttpHeader_XForwardedFor=xff" + + "|RequestHttpHeader_XForwardedHost=xfh" + + "|RequestHttpHeader_XForwardedProto=xfp" + + "|ConfigVersion=NULL" + + "|Exception=integrationConfigJson is not valid json." + + assert( requestMock.cookie_jar.length == 1 ) + assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) + actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] + assert( expectedCookieValue.eql?(actualCookieValue) ) + end + + def test_ValidateRequestByIntegrationConfig_Debug_Missing_CustomerId + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.validateRequestByIntegrationConfig( + "http://test.com?event1=true", expiredDebugToken, "{}", nil, "secretKey", + requestMock) + + assert( "https://api2.queue-it.net/diagnostics/connector/error/?code=setup" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_ValidateRequestByIntegrationConfig_Debug_Missing_Secretkey + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.validateRequestByIntegrationConfig( + "http://test.com?event1=true", expiredDebugToken, "{}", "customerId", nil, + requestMock) + + assert( "https://api2.queue-it.net/diagnostics/connector/error/?code=setup" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_ValidateRequestByIntegrationConfig_Debug_ExpiredToken + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.validateRequestByIntegrationConfig( + "http://test.com?event1=true", expiredDebugToken, "{}", "customerId", "secretKey", + requestMock) + + assert( "https://customerId.api2.queue-it.net/customerId/diagnostics/connector/error/?code=timestamp" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_ValidateRequestByIntegrationConfig_Debug_ModifiedToken + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + invalidDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", false) + "invalid-hash" + + result = KnownUser.validateRequestByIntegrationConfig( + "http://test.com?event1=true", invalidDebugToken, "{}", "customerId", "secretKey", + requestMock) + + assert( "https://customerId.api2.queue-it.net/customerId/diagnostics/connector/error/?code=hash" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_ResolveQueueRequestByLocalConfig_Debug + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + queueConfig = QueueEventConfig.new + queueConfig.cookieDomain = "cookieDomain" + queueConfig.layoutName = "layoutName" + queueConfig.culture = "culture" + queueConfig.eventId = "eventId" + queueConfig.queueDomain = "queueDomain" + queueConfig.extendCookieValidity = true + queueConfig.cookieValidityMinute = 10 + queueConfig.version = 12 + queueConfig.actionName = "QueueAction" + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + + secretKey = "secretKey" + queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", secretKey, false) + + expectedServerTime = Time.now.utc.iso8601 + KnownUser.resolveQueueRequestByLocalConfig("url", queueitToken, queueConfig, "customerId", secretKey, requestMock) + + expectedCookieValue = + "SdkVersion=" + UserInQueueService::SDK_VERSION + + "|Runtime=" + RUBY_VERSION.to_s + + "|TargetUrl=url|QueueitToken=" + queueitToken + + "|OriginalUrl=http://localhost/original_url" + + "|QueueConfig=EventId:eventId&Version:12&QueueDomain:queueDomain&CookieDomain:cookieDomain&ExtendCookieValidity:true&CookieValidityMinute:10&LayoutName:layoutName&Culture:culture&ActionName:QueueAction" + + "|ServerUtcTime=" + expectedServerTime + + "|RequestIP=userIP" + + "|RequestHttpHeader_Via=v" + + "|RequestHttpHeader_Forwarded=f" + + "|RequestHttpHeader_XForwardedFor=xff" + + "|RequestHttpHeader_XForwardedHost=xfh" + + "|RequestHttpHeader_XForwardedProto=xfp" + + assert( requestMock.cookie_jar.length == 1 ) + assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) + actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] + assert( expectedCookieValue.eql?(actualCookieValue) ) + end + + def test_ResolveQueueRequestByLocalConfig_Debug_NullConfig + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + + queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", false) + expectedServerTime = Time.now.utc.iso8601 + + errorThrown = false + begin + KnownUser.resolveQueueRequestByLocalConfig("http://test.com?event1=true", queueitToken, + nil, "customerId", "secretKey", requestMock) + rescue KnownUserError => err + errmsg = err.message + errorThrown = err.message.start_with? "queueConfig can not be nil." + end + + assert( errorThrown ) + + expectedCookieValue = + "SdkVersion=" + UserInQueueService::SDK_VERSION + + "|Runtime=" + RUBY_VERSION.to_s + + "|TargetUrl=http://test.com?event1=true" + + "|QueueitToken=" + queueitToken + + "|OriginalUrl=http://localhost/original_url" + + "|QueueConfig=NULL" + + "|ServerUtcTime=" + expectedServerTime + + "|RequestIP=userIP" + + "|RequestHttpHeader_Via=v" + + "|RequestHttpHeader_Forwarded=f" + + "|RequestHttpHeader_XForwardedFor=xff" + + "|RequestHttpHeader_XForwardedHost=xfh" + + "|RequestHttpHeader_XForwardedProto=xfp" + + "|Exception=queueConfig can not be nil." + + assert( requestMock.cookie_jar.length == 1 ) + assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) + actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] + assert( expectedCookieValue.eql?(actualCookieValue) ) + end + + def test_ResolveQueueRequestByLocalConfig_Debug_Missing_CustomerId + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + queueConfig = QueueEventConfig.new + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.resolveQueueRequestByLocalConfig( + "http://test.com?event1=true", expiredDebugToken, queueConfig, nil, "secretKey", + requestMock) + + assert( "https://api2.queue-it.net/diagnostics/connector/error/?code=setup" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_ResolveQueueRequestByLocalConfig_Debug_Missing_SecretKey + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + queueConfig = QueueEventConfig.new + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.resolveQueueRequestByLocalConfig( + "http://test.com?event1=true", expiredDebugToken, queueConfig, "customerId", nil, + requestMock) + + assert( "https://api2.queue-it.net/diagnostics/connector/error/?code=setup" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_ResolveQueueRequestByLocalConfig_Debug_ExpiredToken + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + queueConfig = QueueEventConfig.new + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.resolveQueueRequestByLocalConfig( + "http://test.com?event1=true", expiredDebugToken, queueConfig, "customerId", "secretKey", + requestMock) + + assert( "https://customerId.api2.queue-it.net/customerId/diagnostics/connector/error/?code=timestamp" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_ResolveQueueRequestByLocalConfig_Debug_ModifiedToken + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + queueConfig = QueueEventConfig.new + invalidDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", false) + "invalid-hash" + + result = KnownUser.resolveQueueRequestByLocalConfig( + "http://test.com?event1=true", invalidDebugToken, queueConfig, "customerId", "secretKey", + requestMock) + + assert( "https://customerId.api2.queue-it.net/customerId/diagnostics/connector/error/?code=hash" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_CancelRequestByLocalConfig_Debug + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + cancelConfig = CancelEventConfig.new + cancelConfig.eventId = "eventId" + cancelConfig.queueDomain = "queueDomain" + cancelConfig.version = 1 + cancelConfig.cookieDomain = "cookieDomain" + cancelConfig.actionName = "CancelAction" + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + + secretKey = "secretKey" + queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", secretKey, false) + + expectedServerTime = Time.now.utc.iso8601 + KnownUser.cancelRequestByLocalConfig("url", queueitToken, cancelConfig, "customerId", secretKey, requestMock) + + expectedCookieValue = + "SdkVersion=" + UserInQueueService::SDK_VERSION + + "|Runtime=" + RUBY_VERSION.to_s + + "|TargetUrl=url|QueueitToken=" + queueitToken + + "|OriginalUrl=http://localhost/original_url" + + "|CancelConfig=EventId:eventId&Version:1&QueueDomain:queueDomain&CookieDomain:cookieDomain&ActionName:" + cancelConfig.actionName + + "|ServerUtcTime=" + expectedServerTime + + "|RequestIP=userIP" + + "|RequestHttpHeader_Via=v" + + "|RequestHttpHeader_Forwarded=f" + + "|RequestHttpHeader_XForwardedFor=xff" + + "|RequestHttpHeader_XForwardedHost=xfh" + + "|RequestHttpHeader_XForwardedProto=xfp" + + assert( requestMock.cookie_jar.length == 1 ) + assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) + + actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] + assert( expectedCookieValue.eql?(actualCookieValue) ) + end + + def test_CancelRequestByLocalConfig_Debug_NullConfig + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + + queueitToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", false) + expectedServerTime = Time.now.utc.iso8601 + + errorThrown = false + begin + KnownUser.cancelRequestByLocalConfig("http://test.com?event1=true", queueitToken, + nil, "customerId", "secretKey", requestMock) + rescue KnownUserError => err + errmsg = err.message + errorThrown = err.message.start_with? "cancelConfig can not be nil." + end + + assert( errorThrown ) + + expectedCookieValue = + "SdkVersion=" + UserInQueueService::SDK_VERSION + + "|Runtime=" + RUBY_VERSION.to_s + + "|TargetUrl=http://test.com?event1=true" + + "|QueueitToken=" + queueitToken + + "|OriginalUrl=http://localhost/original_url" + + "|CancelConfig=NULL" + + "|ServerUtcTime=" + expectedServerTime + + "|RequestIP=userIP" + + "|RequestHttpHeader_Via=v" + + "|RequestHttpHeader_Forwarded=f" + + "|RequestHttpHeader_XForwardedFor=xff" + + "|RequestHttpHeader_XForwardedHost=xfh" + + "|RequestHttpHeader_XForwardedProto=xfp" + + "|Exception=cancelConfig can not be nil." + + assert( requestMock.cookie_jar.length == 1 ) + assert( requestMock.cookie_jar.key?(KnownUser::QUEUEIT_DEBUG_KEY.to_sym) ) + actualCookieValue = requestMock.cookie_jar[KnownUser::QUEUEIT_DEBUG_KEY.to_sym]["value".to_sym] + assert( expectedCookieValue.eql?(actualCookieValue) ) + end + + def test_CancelRequestByLocalConfig_Debug_Missing_CustomerId + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + cancelConfig = CancelEventConfig.new + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.cancelRequestByLocalConfig( + "http://test.com?event1=true", expiredDebugToken, cancelConfig, nil, "secretKey", + requestMock) + + assert( "https://api2.queue-it.net/diagnostics/connector/error/?code=setup" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_CancelRequestByLocalConfig_Debug_Missing_SecretKey + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + cancelConfig = CancelEventConfig.new + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.cancelRequestByLocalConfig( + "http://test.com?event1=true", expiredDebugToken, cancelConfig, "customerId", nil, + requestMock) + + assert( "https://api2.queue-it.net/diagnostics/connector/error/?code=setup" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_CancelRequestByLocalConfig_Debug_ExpiredToken + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + cancelConfig = CancelEventConfig.new + expiredDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", true) + + result = KnownUser.cancelRequestByLocalConfig( + "http://test.com?event1=true", expiredDebugToken, cancelConfig, "customerId", "secretKey", + requestMock) + + assert( "https://customerId.api2.queue-it.net/customerId/diagnostics/connector/error/?code=timestamp" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_CancelRequestByLocalConfig_Debug_ModifiedToken + requestMock = HttpRequestMock.new + requestMock.cookie_jar = {} + + cancelConfig = CancelEventConfig.new + invalidDebugToken = QueueITTokenGenerator::generateDebugToken("eventId", "secretKey", false) + "invalid-hash" + + result = KnownUser.cancelRequestByLocalConfig( + "http://test.com?event1=true", invalidDebugToken, cancelConfig, "customerId", "secretKey", + requestMock) + + assert( "https://customerId.api2.queue-it.net/customerId/diagnostics/connector/error/?code=hash" == result.redirectUrl ) + assert( requestMock.cookie_jar.length == 0 ) + end + + def test_CancelRequestByLocalConfig_Exception_NoDebugToken_NoDebugCookie + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + cancelConfig = CancelEventConfig.new + cancelConfig.eventId = "eventId" + cancelConfig.queueDomain = "queueDomain" + cancelConfig.version = 1 + cancelConfig.cookieDomain = "cookieDomain" + cancelConfig.actionName = "CancelAction" + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + userInQueueService.validateCancelRequestRaiseException = true + begin + result = KnownUser.cancelRequestByLocalConfig("targetUrl", "token", cancelConfig, "customerId", "secretKey", HttpRequestMock.new) + rescue Exception => e + assert(e.message == "Exception") + end + assert( requestMock.cookie_jar.length == 0 ) + assert( userInQueueService.validateCancelRequestCalls.length > 0 ) + end + + def test_ValidateRequestByIntegrationConfig_Exception_NoDebugToken_NoDebugCookie + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + integrationConfig = + { + :Description => "test", + :Integrations => + [ + { + :Name => "event1action", + :ActionType => "Cancel", + :EventId => "event1", + :CookieDomain => ".test.com", + :Triggers => + [ + { + :TriggerParts => + [ + { + :Operator => "Contains", + :ValueToCompare => "event1", + :UrlPart => "PageUrl", + :ValidatorType => "UrlValidator", + :IsNegative => false, + :IsIgnoreCase => true + } + ], + :LogicalOperator => "And" + } + ], + :QueueDomain => "knownusertest.queue-it.net", + } + ], + :CustomerId => "knownusertest", + :AccountId => "knownusertest", + :Version => 3, + :PublishDate => "2017-05-15T21:39:12.0076806Z", + :ConfigDataVersion => "1.0.0.1" + } + + integrationConfigJson = JSON.generate(integrationConfig) + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + userInQueueService.validateCancelRequestRaiseException = true + begin + result = KnownUser.validateRequestByIntegrationConfig("http://test.com?event1=true", "queueIttoken", integrationConfigJson, "customerid", "secretkey", requestMock) + rescue Exception => e + assert(e.message == "Exception") + end + assert( requestMock.cookie_jar.length == 0 ) + assert( userInQueueService.validateCancelRequestCalls.length > 0 ) + end + + def test_ResolveQueueRequestByLocalConfig_Exception_NoDebugToken_NoDebugCookie + userInQueueService = UserInQueueServiceMock.new + KnownUser.class_variable_set(:@@userInQueueService, userInQueueService) + + queueConfig = QueueEventConfig.new + queueConfig.cookieDomain = "cookieDomain" + queueConfig.layoutName = "layoutName" + queueConfig.culture = "culture" + queueConfig.eventId = "eventId" + queueConfig.queueDomain = "queueDomain" + queueConfig.extendCookieValidity = true + queueConfig.cookieValidityMinute = 10 + queueConfig.version = 12 + queueConfig.actionName = "QueueAction" + + requestMock = HttpRequestMock.new + requestMock.setRealOriginalUrl("http", "localhost", "/original_url") + requestMock.cookie_jar = {} + requestMock.remote_ip = "userIP" + requestMock.headers = { + "via" => "v", + "forwarded" => "f", + "x-forwarded-for" => "xff", + "x-forwarded-host" => "xfh", + "x-forwarded-proto" => "xfp" } + userInQueueService.validateQueueRequestRaiseException = true + begin + result = KnownUser.resolveQueueRequestByLocalConfig("target", "token", queueConfig, "id", "key", requestMock) + rescue Exception => e + assert(e.message == "Exception") + end + assert( requestMock.cookie_jar.length == 0 ) + assert( userInQueueService.validateQueueRequestCalls.length > 0 ) end end -end \ No newline at end of file +end diff --git a/test/queueit_knownuserv3/test_queue_url_params.rb b/test/queueit_knownuserv3/test_queue_url_params.rb index f3828bb..1d5a385 100644 --- a/test/queueit_knownuserv3/test_queue_url_params.rb +++ b/test/queueit_knownuserv3/test_queue_url_params.rb @@ -17,7 +17,8 @@ def test_extractQueueParams end def test_extractQueueParams_notValidToken - queueITToken = "ts_sasa~cv_adsasa~ce_falwwwse~q_944c1f44-60dd-4e37-aabc-f3e4bb1c8895"; + queueITToken = "ts_sasa~cv_adsasa~ce_falwwwse~q_944c1f44-60dd-4e37-aabc-f3e4bb1c8895~h_218b734e-d5be-4b60-ad66-9b1b326266e2" + queueitTokenWithoutHash = "ts_sasa~cv_adsasa~ce_falwwwse~q_944c1f44-60dd-4e37-aabc-f3e4bb1c8895" result = QueueUrlParams.extractQueueParams(queueITToken); assert( result.eventId.empty? ) assert( result.timeStamp == 0 ) @@ -25,8 +26,26 @@ def test_extractQueueParams_notValidToken assert( result.queueITToken.eql? queueITToken ) assert( result.cookieValidityMinutes.nil? ) assert( result.queueId.eql? "944c1f44-60dd-4e37-aabc-f3e4bb1c8895" ) - assert( result.hashCode.empty? ) - assert( result.queueITTokenWithoutHash.eql? "ts_sasa~cv_adsasa~ce_falwwwse~q_944c1f44-60dd-4e37-aabc-f3e4bb1c8895" ) + assert( result.hashCode.eql? "218b734e-d5be-4b60-ad66-9b1b326266e2") + assert( result.queueITTokenWithoutHash.eql? queueitTokenWithoutHash) + end + + def test_extractQueueParams_using_queueitToken_with_no_values + queueITToken = "e~q~ts~ce~rt~h" + result = QueueUrlParams.extractQueueParams(queueITToken); + assert( result.eventId.empty? ) + assert( result.timeStamp == 0 ) + assert( result.extendableCookie.eql? false ) + assert( result.queueITToken.eql? queueITToken ) + assert( result.cookieValidityMinutes.nil? ) + assert( result.queueId.eql? "" ) + assert( result.hashCode.empty?) + assert( result.queueITTokenWithoutHash.eql? queueITToken) + end + + def test_extractQueueParams_using_no_queueitToken_expect_nil + result = QueueUrlParams.extractQueueParams(""); + assert( result.nil? ) end end end \ No newline at end of file diff --git a/test/queueit_knownuserv3/test_user_in_queue_service.rb b/test/queueit_knownuserv3/test_user_in_queue_service.rb index 00c6868..d8213e4 100644 --- a/test/queueit_knownuserv3/test_user_in_queue_service.rb +++ b/test/queueit_knownuserv3/test_user_in_queue_service.rb @@ -88,6 +88,7 @@ def test_ValidateQueueRequest_ValidState_ExtendableCookie_NoCookieExtensionFromC queueConfig.cookieDomain = "testDomain" queueConfig.cookieValidityMinute = 10 queueConfig.extendCookieValidity = false + queueConfig.actionName = "QueueAction" cookieProviderMock = UserInQueueStateRepositoryMockClass.new() cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(true, "queueId", nil, "idle")) testObject = UserInQueueService.new(cookieProviderMock) @@ -95,8 +96,10 @@ def test_ValidateQueueRequest_ValidState_ExtendableCookie_NoCookieExtensionFromC assert(!result.doRedirect()) assert(result.queueId == "queueId") + assert(result.actionName == queueConfig.actionName) assert(!cookieProviderMock.expectCallAny('store')) assert(cookieProviderMock.expectCall('getState', 1,["e1", 10, 'key', true])) + assert(!cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateQueueRequest_ValidState_ExtendableCookie_CookieExtensionFromConfig_DoNotRedirectDoStoreCookieWithExtension @@ -106,7 +109,8 @@ def test_ValidateQueueRequest_ValidState_ExtendableCookie_CookieExtensionFromCon queueConfig.cookieDomain = "testDomain" queueConfig.cookieValidityMinute=10 queueConfig.extendCookieValidity=true - + queueConfig.actionName = "QueueAction" + cookieProviderMock = UserInQueueStateRepositoryMockClass.new() cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(true, "queueId", nil, "disabled")) testObject = UserInQueueService.new(cookieProviderMock) @@ -114,8 +118,9 @@ def test_ValidateQueueRequest_ValidState_ExtendableCookie_CookieExtensionFromCon assert(!result.doRedirect()) assert(result.eventId == 'e1') assert(result.queueId == "queueId") - + assert(result.actionName == queueConfig.actionName) assert(cookieProviderMock.expectCall('store', 1, ["e1", 'queueId', nil, 'testDomain', "disabled", "key"])) + assert(!cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateQueueRequest_ValidState_NoExtendableCookie_DoNotRedirectDoNotStoreCookieWithExtension @@ -124,6 +129,8 @@ def test_ValidateQueueRequest_ValidState_NoExtendableCookie_DoNotRedirectDoNotSt queueConfig.queueDomain = "testDomain" queueConfig.cookieValidityMinute = 10 queueConfig.extendCookieValidity = true + queueConfig.actionName = "QueueAction" + cookieProviderMock = UserInQueueStateRepositoryMockClass.new() cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(true, "queueId", 3, "idle")) testObject = UserInQueueService.new(cookieProviderMock) @@ -131,7 +138,9 @@ def test_ValidateQueueRequest_ValidState_NoExtendableCookie_DoNotRedirectDoNotSt assert(!result.doRedirect()) assert(result.eventId == 'e1') assert(result.queueId == "queueId") + assert(result.actionName == queueConfig.actionName) assert(!cookieProviderMock.expectCallAny('store')) + assert(!cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateQueueRequest_NoCookie_TampredToken_RedirectToErrorPageWithHashError_DoNotStoreCookie @@ -142,6 +151,7 @@ def test_ValidateQueueRequest_NoCookie_TampredToken_RedirectToErrorPageWithHashE queueConfig.cookieValidityMinute = 10 queueConfig.extendCookieValidity = true queueConfig.version = 11 + queueConfig.actionName = "QueueAction" url = "http://test.test.com?b=h" cookieProviderMock = UserInQueueStateRepositoryMockClass.new() @@ -151,23 +161,25 @@ def test_ValidateQueueRequest_NoCookie_TampredToken_RedirectToErrorPageWithHashE token = token.sub("False", 'True') expectedErrorUrl = "https://testDomain.com/error/hash/?c=testCustomer&e=e1" + - "&ver=v3-ruby-" + UserInQueueService::SDK_VERSION + + "&ver=" + UserInQueueService::SDK_VERSION + "&cver=11" + + "&man=" + queueConfig.actionName + "&queueittoken=" + token + - "&t=" + CGI.escape(url) + "&t=" + Utils.urlEncode(url) testObject = UserInQueueService.new(cookieProviderMock) result = testObject.validateQueueRequest(url, token, queueConfig, "testCustomer", key) assert(!cookieProviderMock.expectCallAny('store')) assert(result.doRedirect()) assert(result.eventId == 'e1') - + assert(result.actionName == queueConfig.actionName) matches = /&ts=[^&]*/.match(result.redirectUrl) timestamp = matches[0].sub("&ts=", "") timestamp = timestamp.sub("&", "") assert(Time.now.getutc.to_i - timestamp.to_i < 100) urlWithoutTimeStamp = result.redirectUrl.gsub(/&ts=[^&]*/, "") - assert(urlWithoutTimeStamp.upcase() == expectedErrorUrl.upcase()) + assert(urlWithoutTimeStamp.upcase() == expectedErrorUrl.upcase()) + assert(cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateQueueRequest_NoCookie_ExpiredTimeStampInToken_RedirectToErrorPageWithTimeStampError_DoNotStoreCookie @@ -178,27 +190,31 @@ def test_ValidateQueueRequest_NoCookie_ExpiredTimeStampInToken_RedirectToErrorPa queueConfig.cookieValidityMinute = 10 queueConfig.extendCookieValidity = true queueConfig.version = 11 + queueConfig.actionName = "QueueAction" url = "http://test.test.com?b=h" cookieProviderMock = UserInQueueStateRepositoryMockClass.new cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(false, nil, nil, nil)) token = generateHash('e1','queueId', (Time.now.getutc.to_i - (3 * 60)).to_s, 'False', nil, 'queue', key) expectedErrorUrl = "https://testDomain.com/error/timestamp/?c=testCustomer&e=e1" + - "&ver=v3-ruby-" + UserInQueueService::SDK_VERSION + - "&cver=11" + + "&ver=" + UserInQueueService::SDK_VERSION + + "&cver=11" + + "&man=" + queueConfig.actionName + "&queueittoken=" + token + - "&t=" + CGI.escape(url) + "&t=" + Utils.urlEncode(url) testObject = UserInQueueService.new(cookieProviderMock) result = testObject.validateQueueRequest(url, token, queueConfig, "testCustomer", key) assert(!cookieProviderMock.expectCallAny('store')) assert(result.doRedirect()) assert(result.eventId == 'e1') + assert(result.actionName == queueConfig.actionName) matches = /&ts=[^&]*/.match(result.redirectUrl) timestamp = matches[0].sub("&ts=", "") timestamp =timestamp.sub("&", "") assert(Time.now.getutc.to_i - timestamp.to_i < 100) urlWithoutTimeStamp = result.redirectUrl.gsub(/&ts=[^&]*/, "") assert(urlWithoutTimeStamp.upcase == expectedErrorUrl.upcase) + assert(cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateQueueRequest_NoCookie_EventIdMismatch_RedirectToErrorPageWithEventIdMissMatchError_DoNotStoreCookie @@ -209,25 +225,29 @@ def test_ValidateQueueRequest_NoCookie_EventIdMismatch_RedirectToErrorPageWithEv queueConfig.cookieValidityMinute = 10 queueConfig.extendCookieValidity = true queueConfig.version = 11 + queueConfig.actionName = "QueueAction" url = "http://test.test.com?b=h" cookieProviderMock = UserInQueueStateRepositoryMockClass.new cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(false, nil, nil, nil)) token = generateHash('e1', 'queueId',(Time.now.getutc.to_i - (3 * 60)).to_s, 'False', nil, 'queue', key) expectedErrorUrl = "https://testDomain.com/error/eventid/?c=testCustomer&e=e2" + - "&ver=v3-ruby-" + UserInQueueService::SDK_VERSION + "&cver=11" + + "&ver=" + UserInQueueService::SDK_VERSION + "&cver=11" + + "&man=" + queueConfig.actionName + "&queueittoken=" + token + - "&t=" + CGI.escape(url) + "&t=" + Utils.urlEncode(url) testObject = UserInQueueService.new(cookieProviderMock) result = testObject.validateQueueRequest(url, token, queueConfig, "testCustomer", key) assert(!cookieProviderMock.expectCallAny('store')) assert(result.doRedirect()) assert(result.eventId == 'e2') + assert(result.actionName == queueConfig.actionName) matches = /&ts=[^&]*/.match(result.redirectUrl) timestamp = matches[0].sub("&ts=", "") timestamp = timestamp.sub("&", "") assert(Time.now.getutc.to_i - timestamp.to_i < 100) urlWithoutTimeStamp = result.redirectUrl.gsub(/&ts=[^&]*/, "") assert(urlWithoutTimeStamp.upcase == expectedErrorUrl.upcase) + assert(cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateQueueRequest_NoCookie_ValidToken_ExtendableCookie_DoNotRedirect_StoreExtendableCookie @@ -239,6 +259,7 @@ def test_ValidateQueueRequest_NoCookie_ValidToken_ExtendableCookie_DoNotRedirect queueConfig.cookieDomain = "testDomain" queueConfig.extendCookieValidity = true queueConfig.version = 11 + queueConfig.actionName = "QueueAction" url = "http://test.test.com?b=h" cookieProviderMock = UserInQueueStateRepositoryMockClass.new cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(false, nil, nil, nil)) @@ -250,7 +271,9 @@ def test_ValidateQueueRequest_NoCookie_ValidToken_ExtendableCookie_DoNotRedirect assert(result.eventId == 'e1') assert(result.queueId == 'queueId') assert(result.redirectType == 'queue') + assert(result.actionName == queueConfig.actionName) assert(cookieProviderMock.expectCall('store', 1, ["e1", 'queueId', nil, 'testDomain', 'queue', key])) + assert(!cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateQueueRequest_NoCookie_ValidToken_CookieValidityMinuteFromToken_DoNotRedirect_StoreNonExtendableCookie @@ -262,6 +285,7 @@ def test_ValidateQueueRequest_NoCookie_ValidToken_CookieValidityMinuteFromToken_ queueConfig.cookieDomain = "testDomain" queueConfig.extendCookieValidity = true queueConfig.version = 11 + queueConfig.actionName = "QueueAction" url = "http://test.test.com?b=h" cookieProviderMock = UserInQueueStateRepositoryMockClass.new() cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(false, nil, nil, nil)) @@ -272,7 +296,9 @@ def test_ValidateQueueRequest_NoCookie_ValidToken_CookieValidityMinuteFromToken_ assert(result.eventId == 'e1') assert(result.queueId == 'queueId') assert(result.redirectType == 'DirectLink') + assert(result.actionName == queueConfig.actionName) assert(cookieProviderMock.expectCall('store', 1, ["e1",'queueId', 3, 'testDomain', 'DirectLink', key])) + assert(!cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_NoCookie_NoValidToken_WithoutToken_RedirectToQueue() @@ -285,13 +311,16 @@ def test_NoCookie_NoValidToken_WithoutToken_RedirectToQueue() queueConfig.version = 11 queueConfig.culture = 'en-US' queueConfig.layoutName = 'testlayout' + queueConfig.actionName = "QueueAction" url = "http://test.test.com?b=h" cookieProviderMock = UserInQueueStateRepositoryMockClass.new() cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(false, nil, nil, nil)) token = "" - expectedRedirectUrl = "https://testDomain.com?c=testCustomer&e=e1" + - "&ver=v3-ruby-" + UserInQueueService::SDK_VERSION + "&cver=11" + "&cid=en-US" + - "&l=testlayout"+"&t=" + CGI.escape(url) + expectedRedirectUrl = "https://testDomain.com/?c=testCustomer&e=e1" + + "&ver=" + UserInQueueService::SDK_VERSION + "&cver=11" + + "&man=" + queueConfig.actionName + + "&cid=en-US" + + "&l=testlayout"+"&t=" + Utils.urlEncode(url) testObject = UserInQueueService.new(cookieProviderMock) result = testObject.validateQueueRequest(url, token, queueConfig, "testCustomer", key) assert(!cookieProviderMock.expectCallAny('store')) @@ -299,6 +328,8 @@ def test_NoCookie_NoValidToken_WithoutToken_RedirectToQueue() assert(result.eventId == 'e1') assert(result.queueId == nil) assert(result.redirectUrl.upcase() == expectedRedirectUrl.upcase()) + assert(result.actionName == queueConfig.actionName) + assert(cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateRequest_NoCookie_WithoutToken_RedirectToQueue_NotargetUrl @@ -311,11 +342,14 @@ def test_ValidateRequest_NoCookie_WithoutToken_RedirectToQueue_NotargetUrl queueConfig.version = 11 queueConfig.culture = 'en-US' queueConfig.layoutName = 'testlayout' + queueConfig.actionName = "QueueAction" cookieProviderMock = UserInQueueStateRepositoryMockClass.new() cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(false, nil, nil, nil)) token = "" - expectedRedirectUrl = "https://testDomain.com?c=testCustomer&e=e1" + - "&ver=v3-ruby-" + UserInQueueService::SDK_VERSION + "&cver=11" + "&cid=en-US" + + expectedRedirectUrl = "https://testDomain.com/?c=testCustomer&e=e1" + + "&ver=" + UserInQueueService::SDK_VERSION + "&cver=11" + + "&man=" + queueConfig.actionName + + "&cid=en-US" + "&l=testlayout" testObject = UserInQueueService.new(cookieProviderMock) result = testObject.validateQueueRequest(nil, token, queueConfig, "testCustomer", key) @@ -324,6 +358,8 @@ def test_ValidateRequest_NoCookie_WithoutToken_RedirectToQueue_NotargetUrl assert(result.eventId == 'e1') assert(result.queueId == nil) assert(result.redirectUrl.upcase() == expectedRedirectUrl.upcase()) + assert(result.actionName == queueConfig.actionName) + assert(cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_ValidateQueueRequest_NoCookie_InValidToken @@ -336,7 +372,16 @@ def test_ValidateQueueRequest_NoCookie_InValidToken queueConfig.version = 11 queueConfig.culture = 'en-US' queueConfig.layoutName = 'testlayout' + queueConfig.actionName = "QueueAction" url = "http://test.test.com?b=h" + + expectedRedirectUrl = "https://testDomain.com/error/hash/?c=testCustomer&e=e1" + + "&ver=" + UserInQueueService::SDK_VERSION + "&cver=11" + + "&man=" + queueConfig.actionName + + "&cid=en-US" + + "&l=testlayout" + + "&queueittoken=ts_sasa~cv_adsasa~ce_falwwwse~q_944c1f44-60dd-4e37-aabc-f3e4bb1c8895" + cookieProviderMock = UserInQueueStateRepositoryMockClass.new cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(false, nil, nil, nil)) testObject = UserInQueueService.new(cookieProviderMock) @@ -345,7 +390,9 @@ def test_ValidateQueueRequest_NoCookie_InValidToken assert(result.doRedirect()) assert(result.eventId == 'e1') assert(result.queueId == nil) - assert(result.redirectUrl.start_with?("https://testDomain.com/error/hash/?c=testCustomer&e=e1")) + assert(result.redirectUrl.start_with?(expectedRedirectUrl)) + assert(result.actionName == queueConfig.actionName) + assert(cookieProviderMock.expectCallAny('cancelQueueCookie')) end def test_validateCancelRequest @@ -354,12 +401,13 @@ def test_validateCancelRequest cancelConfig.queueDomain = "testDomain.com" cancelConfig.cookieDomain = "my-cookie-domain"; cancelConfig.version = 10 - + cancelConfig.actionName = "Cancel Action (._~-&) !*|'\"" url = "http://test.test.com?b=h" cookieProviderMock = UserInQueueStateRepositoryMockClass.new() cookieProviderMock.arrayReturns['getState'].push(StateInfo.new(true, "queueId", 3, "idle")) - expectedUrl = "https://testDomain.com/cancel/testCustomer/e1/?c=testCustomer&e=e1&ver=v3-ruby-" + UserInQueueService::SDK_VERSION + "&cver=10&r=" + CGI.escape(url); - + expectedUrl = "https://testDomain.com/cancel/testCustomer/e1/?c=testCustomer&e=e1&ver=" + UserInQueueService::SDK_VERSION + + "&cver=10&man=" + "Cancel%20Action%20%28._~-%26%29%20%21%2A%7C%27%22" + + "&r=" + Utils.urlEncode(url); testObject = UserInQueueService.new(cookieProviderMock) result = testObject.validateCancelRequest(url, cancelConfig, "testCustomer", "key") @@ -368,17 +416,20 @@ def test_validateCancelRequest assert(result.queueId == "queueId") assert(result.eventId == 'e1') assert(expectedUrl == result.redirectUrl) + assert(result.actionName == cancelConfig.actionName) end def test_getIgnoreActionResult + actionName = "IgnorAction" testObject = UserInQueueService.new(UserInQueueStateRepositoryMockClass.new()) - result = testObject.getIgnoreActionResult() + result = testObject.getIgnoreActionResult(actionName) assert( !result.doRedirect() ) assert( result.eventId.nil? ) assert( result.queueId.nil? ) assert( result.redirectUrl.nil? ) assert( result.actionType.eql? 'Ignore' ) + assert(result.actionName == actionName) end def generateHash(eventId, queueId, timestamp, extendableCookie, cookieValidityMinutes, redirectType, secretKey)