public void Evaluate_Test()
        {
            var triggerPart = new TriggerPart()
            {
                CookieName     = "c1",
                Operator       = ComparisonOperatorType.Contains,
                ValueToCompare = "1"
            };
            var request = new KnownUserTest.MockHttpRequest();

            Assert.False(CookieValidatorHelper.Evaluate(triggerPart, request));

            request.CookiesValue.Add("c5", "5");
            request.CookiesValue.Add("c1", "1");
            request.CookiesValue.Add("c2", "test");
            Assert.True(CookieValidatorHelper.Evaluate(triggerPart, request));

            triggerPart.ValueToCompare = "5";
            Assert.False(CookieValidatorHelper.Evaluate(triggerPart, request));


            triggerPart.ValueToCompare = "Test";
            triggerPart.IsIgnoreCase   = true;
            triggerPart.CookieName     = "c2";
            Assert.True(CookieValidatorHelper.Evaluate(triggerPart, request));

            triggerPart.ValueToCompare = "Test";
            triggerPart.IsIgnoreCase   = true;
            triggerPart.IsNegative     = true;
            triggerPart.CookieName     = "c2";
            Assert.False(CookieValidatorHelper.Evaluate(triggerPart, request));
        }
        public void GetState_OldCookie_InValid_ExpiredCookie_NonExtendable()
        {
            var eventId   = "event1";
            var secretKey = "4e1db821-a825-49da-acd0-5d376f2068db";

            var queueId   = "f8757c2d-34c2-4639-bef2-1736cdd30bbb";
            var cookieKey = UserInQueueStateCookieRepository.GetCookieKey(eventId);

            var issueTime = DateTimeHelper.GetUnixTimeStampFromDate(DateTime.UtcNow.AddMinutes(-4));
            var hash      = QueueITTokenGenerator.GetSHA256Hash(eventId.ToLower() + queueId + "3" + "idle" + issueTime.ToString(),
                                                                secretKey);
            var cookieValue = HttpUtility.UrlEncode($"EventId={eventId}&QueueId={queueId}&{_FixedCookieValidityMinutesKey}=3&RedirectType=idle&IssueTime={issueTime}&Hash={hash}");

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeRequest = new KnownUserTest.MockHttpRequest()
            {
                CookiesValue = new NameValueCollection()
                {
                    { cookieKey, cookieValue }
                }
            };

            fakeContext.HttpRequest = fakeRequest;
            var fakeResponse = new KnownUserTest.MockHttpResponse()
            {
            };

            fakeContext.HttpResponse = fakeResponse;

            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            var state = testObject.GetState(eventId, 10, secretKey);

            Assert.True(!state.IsValid);
        }
        public void GetState_InvalidCookie_StateIsNotValid()
        {
            var eventId   = "event1";
            var secretKey = "4e1db821-a825-49da-acd0-5d376f2068db";

            var cookieKey = UserInQueueStateCookieRepository.GetCookieKey(eventId);

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeRequest = new KnownUserTest.MockHttpRequest()
            {
                CookiesValue = new NameValueCollection()
                {
                    { cookieKey, "Expires=odoododod&FixedCookieValidity=yes&jj=101" }
                }
            };

            fakeContext.HttpRequest = fakeRequest;
            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            var state = testObject.GetState(eventId, 10, secretKey);

            Assert.False(state.IsValid);
            Assert.False(state.IsStateExtendable);
            Assert.True(String.IsNullOrEmpty(state.QueueId));
        }
        public void ExtendQueueCookie_CookieDoesNotExist_Test()
        {
            var eventId   = "event1";
            var secretKey = "secretKey";
            var cookieKey = UserInQueueStateCookieRepository.GetCookieKey(eventId);

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeRequest = new KnownUserTest.MockHttpRequest()
            {
            };

            fakeContext.HttpRequest = fakeRequest;
            var fakeResponse = new KnownUserTest.MockHttpResponse()
            {
            };

            fakeContext.HttpResponse = fakeResponse;

            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            testObject.ReissueQueueCookie(eventId, 12, "testdomain", secretKey);

            var state = testObject.GetState(eventId, 12, secretKey);

            Assert.False(state.IsValid);
            Assert.False(state.IsStateExtendable);
            Assert.True(String.IsNullOrEmpty(state.QueueId));
        }
Beispiel #5
0
        public void GetMatchedIntegrationConfig_OneTrigger_And_NotMatched_UserAgent()
        {
            var testObject = new IntegrationEvaluator();

            var customerIntegration = new CustomerIntegration
            {
                Integrations = new List <IntegrationConfigModel>
                {
                    new IntegrationConfigModel
                    {
                        Name     = "integration1",
                        Triggers = new List <TriggerModel>
                        {
                            new TriggerModel
                            {
                                LogicalOperator = LogicalOperatorType.And,
                                TriggerParts    = new List <TriggerPart>
                                {
                                    new TriggerPart
                                    {
                                        CookieName     = "c1",
                                        Operator       = ComparisonOperatorType.EqualS,
                                        IsIgnoreCase   = true,
                                        ValueToCompare = "value1",
                                        ValidatorType  = ValidatorType.CookieValidator
                                    },
                                    new TriggerPart
                                    {
                                        UrlPart        = UrlPartType.PageUrl,
                                        ValidatorType  = ValidatorType.UrlValidator,
                                        ValueToCompare = "test",
                                        Operator       = ComparisonOperatorType.Contains
                                    },
                                    new TriggerPart
                                    {
                                        ValidatorType  = ValidatorType.UserAgentValidator,
                                        ValueToCompare = "Googlebot",
                                        Operator       = ComparisonOperatorType.Contains,
                                        IsIgnoreCase   = true,
                                        IsNegative     = true
                                    }
                                }
                            }
                        }
                    }
                }
            };

            var url = new Uri("http://test.tesdomain.com:8080/test?q=2");

            var httpRequestMock = new KnownUserTest.MockHttpRequest
            {
                CookiesValue = new NameValueCollection {
                    { "c1", "Value1" }
                },
                UserAgent = "bot.html google.com googlebot test"
            };

            Assert.True(testObject.GetMatchedIntegrationConfig(customerIntegration, url.AbsoluteUri, httpRequestMock) == null);
        }
        public void GetState_NoCookie_StateIsNotValid()
        {
            var eventId   = "event1";
            var secretKey = "4e1db821-a825-49da-acd0-5d376f2068db";

            var cookieKey = UserInQueueStateCookieRepository.GetCookieKey(eventId);

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeResponse = new KnownUserTest.MockHttpResponse()
            {
            };

            fakeContext.HttpResponse = fakeResponse;
            var fakeRequest = new KnownUserTest.MockHttpRequest()
            {
            };

            fakeContext.HttpRequest = fakeRequest;
            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            var state = testObject.GetState(eventId, 10, secretKey);

            Assert.False(state.IsValid);
            Assert.False(state.IsStateExtendable);
            Assert.True(String.IsNullOrEmpty(state.QueueId));
        }
Beispiel #7
0
        public void Evaluate_Test()
        {
            var triggerPart = new TriggerPart
            {
                Operator       = ComparisonOperatorType.Contains,
                ValueToCompare = "test body"
            };
            var request = new KnownUserTest.MockHttpRequest();

            Assert.False(RequestBodyValidatorHelper.Evaluate(triggerPart, request.GetRequestBodyAsString()));

            request.Body = "test body";

            Assert.True(RequestBodyValidatorHelper.Evaluate(triggerPart, request.GetRequestBodyAsString()));

            triggerPart.ValueToCompare = "ZZZ";
            Assert.False(RequestBodyValidatorHelper.Evaluate(triggerPart, request.GetRequestBodyAsString()));

            triggerPart.ValueToCompare = "Test";
            triggerPart.IsIgnoreCase   = true;
            Assert.True(RequestBodyValidatorHelper.Evaluate(triggerPart, request.GetRequestBodyAsString()));

            triggerPart.ValueToCompare = "Test";
            triggerPart.IsIgnoreCase   = true;
            triggerPart.IsNegative     = true;
            Assert.False(RequestBodyValidatorHelper.Evaluate(triggerPart, request.GetRequestBodyAsString()));

            triggerPart.ValueToCompare = "Test";
            triggerPart.IsIgnoreCase   = true;
            triggerPart.IsNegative     = true;
            Assert.False(RequestBodyValidatorHelper.Evaluate(triggerPart, request.GetRequestBodyAsString()));
        }
        public void Store_GetState_NonExtendableCookie_CookieIsSaved()
        {
            var eventId          = "event1";
            var secretKey        = "secretKey";
            var cookieDomain     = ".test.com";
            var isCookieHttpOnly = true;
            var isCookieSecure   = true;
            var queueId          = "f8757c2d-34c2-4639-bef2-1736cdd30bbb";
            var cookieKey        = UserInQueueStateCookieRepository.GetCookieKey(eventId);

            var cookieValidity = 3;

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeResponse = new KnownUserTest.MockHttpResponse
            {
            };

            fakeContext.HttpResponse = fakeResponse;

            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            testObject.Store(eventId, queueId, cookieValidity, cookieDomain, isCookieHttpOnly, isCookieSecure, "idle", secretKey);
            var cookieValue  = fakeResponse.CookiesValue[cookieKey]["cookieValue"].ToString();
            var cookieValues = CookieHelper.ToNameValueCollectionFromValue(cookieValue);

            Assert.Equal("3", cookieValues[_FixedCookieValidityMinutesKey]);
            Assert.True(((DateTime)fakeResponse.CookiesValue[cookieKey]["expiration"]).Subtract(DateTime.UtcNow.AddDays(1)) < TimeSpan.FromMinutes(1));
            Assert.Equal(cookieDomain, fakeResponse.CookiesValue[cookieKey]["domain"].ToString());
            Assert.Equal(isCookieHttpOnly, fakeResponse.CookiesValue[cookieKey]["isHttpOnly"] as bool?);
            Assert.Equal(isCookieSecure, fakeResponse.CookiesValue[cookieKey]["isSecure"] as bool?);
            Assert.True(
                DateTimeHelper.GetDateTimeFromUnixTimeStamp(cookieValues["IssueTime"])
                .Subtract(DateTime.UtcNow) < TimeSpan.FromSeconds(10));


            //retrive
            var fakeRequest = new KnownUserTest.MockHttpRequest
            {
                CookiesValue = new NameValueCollection
                {
                    { "a1", "b1" },
                    { cookieKey, cookieValue }
                }
            };

            fakeContext.HttpRequest = fakeRequest;

            var state = testObject.GetState(eventId, cookieValidity, secretKey);

            Assert.True(state.IsValid);
            Assert.False(state.IsStateExtendable);
            Assert.True(state.QueueId == queueId);
            Assert.True(state.RedirectType == "idle");
            Assert.True(state.FixedCookieValidityMinutes == 3);
        }
        public void GetMatchedIntegrationConfig_OneTrigger_And_Matched()
        {
            var testObject = new IntegrationEvaluator();

            var customerIntegration = new CustomerIntegration()
            {
                Integrations = new List <IntegrationConfigModel> {
                    new IntegrationConfigModel()
                    {
                        Name     = "integration1",
                        Triggers = new List <TriggerModel>()
                        {
                            new TriggerModel()
                            {
                                LogicalOperator = LogicalOperatorType.And,
                                TriggerParts    = new List <TriggerPart>()
                                {
                                    new TriggerPart()
                                    {
                                        CookieName     = "c1",
                                        Operator       = ComparisonOperatorType.EqualS,
                                        IsIgnoreCase   = true,
                                        ValueToCompare = "value1",
                                        ValidatorType  = ValidatorType.CookieValidator
                                    },
                                    new TriggerPart()
                                    {
                                        UrlPart        = UrlPartType.PageUrl,
                                        ValidatorType  = ValidatorType.UrlValidator,
                                        ValueToCompare = "test",
                                        Operator       = ComparisonOperatorType.Contains
                                    }
                                }
                            }
                        }
                    }
                }
            };


            var url = new Uri("http://test.tesdomain.com:8080/test?q=2");


            var httpRequestMock = new KnownUserTest.MockHttpRequest()
            {
                CookiesValue = new NameValueCollection()
                {
                    { "c1", "Value1" }
                }
            };

            Assert.True(testObject.GetMatchedIntegrationConfig(customerIntegration, url.AbsoluteUri, httpRequestMock).Name == "integration1");
        }
Beispiel #10
0
        public void GetMatchedIntegrationConfig_TwoTriggers_NotMatched()
        {
            var testObject          = new IntegrationEvaluator();
            var customerIntegration = new CustomerIntegration
            {
                Integrations = new List <IntegrationConfigModel>
                {
                    new IntegrationConfigModel
                    {
                        Name     = "integration1",
                        Triggers = new List <TriggerModel>
                        {
                            new TriggerModel
                            {
                                LogicalOperator = LogicalOperatorType.And,
                                TriggerParts    = new List <TriggerPart>
                                {
                                    new TriggerPart
                                    {
                                        CookieName     = "c1",
                                        Operator       = ComparisonOperatorType.EqualS,
                                        ValueToCompare = "value1",
                                        ValidatorType  = ValidatorType.CookieValidator
                                    }
                                }
                            },
                            new TriggerModel
                            {
                                LogicalOperator = LogicalOperatorType.And,
                                TriggerParts    = new List <TriggerPart>
                                {
                                    new TriggerPart
                                    {
                                        UrlPart        = UrlPartType.PageUrl,
                                        ValidatorType  = ValidatorType.UrlValidator,
                                        ValueToCompare = "tesT",
                                        Operator       = ComparisonOperatorType.Contains
                                    }
                                }
                            }
                        }
                    }
                }
            };

            var url = new Uri("http://test.tesdomain.com:8080/test?q=2");

            var httpRequestMock = new KnownUserTest.MockHttpRequest();

            Assert.True(testObject.GetMatchedIntegrationConfig(customerIntegration, url.AbsoluteUri, httpRequestMock) == null);
        }
        public void Store_GetState_ExtendableCookie_CookieIsSaved()
        {
            var eventId        = "event1";
            var secretKey      = "4e1db821-a825-49da-acd0-5d376f2068db";
            var cookieDomain   = ".test.com";
            var queueId        = "f8757c2d-34c2-4639-bef2-1736cdd30bbb";
            var cookieKey      = UserInQueueStateCookieRepository.GetCookieKey(eventId);
            var cookieValidity = 10;

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeResponse = new KnownUserTest.MockHttpResponse()
            {
            };

            fakeContext.HttpResponse = fakeResponse;

            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            testObject.Store(eventId, queueId, null, cookieDomain, "Queue", secretKey);
            var cookieValues = CookieHelper.ToNameValueCollectionFromValue(fakeResponse.CookiesValue[cookieKey]["cookieValue"].ToString());

            Assert.True(((DateTime)fakeResponse.CookiesValue[cookieKey]["expiration"]).Subtract(DateTime.UtcNow.AddDays(1)) < TimeSpan.FromMinutes(1));
            Assert.True(
                DateTimeHelper.GetDateTimeFromUnixTimeStamp(cookieValues["IssueTime"])
                .Subtract(DateTime.UtcNow) < TimeSpan.FromSeconds(10));

            Assert.True(fakeResponse.CookiesValue[cookieKey]["domain"].ToString() == cookieDomain);
            Assert.True(cookieValues["EventId"] == eventId);
            Assert.True(cookieValues["RedirectType"] == "queue");
            Assert.True(cookieValues["QueueId"] == queueId);
            Assert.True(string.IsNullOrEmpty(cookieValues[_FixedCookieValidityMinutesKey]));

            //retrive
            var fakeRequest = new KnownUserTest.MockHttpRequest()
            {
                CookiesValue = new NameValueCollection()
                {
                    { "a1", "b1" },
                    { cookieKey, fakeResponse.CookiesValue[cookieKey]["cookieValue"].ToString() }
                }
            };

            fakeContext.HttpRequest = fakeRequest;
            var state = testObject.GetState(eventId, cookieValidity, secretKey);

            Assert.True(state.IsValid);
            Assert.True(state.IsStateExtendable);
            Assert.True(state.QueueId == queueId);
            Assert.True(state.RedirectType == "queue");
        }
        public void ExtendQueueCookie_CookieExist_Test()
        {
            var eventId   = "event1";
            var secretKey = "4e1db821-a825-49da-acd0-5d376f2068db";

            var queueId     = "f8757c2d-34c2-4639-bef2-1736cdd30bbb";
            var cookieKey   = UserInQueueStateCookieRepository.GetCookieKey(eventId);
            var issueTime   = DateTimeHelper.GetUnixTimeStampFromDate(DateTime.UtcNow.AddMinutes(-1));
            var hash        = QueueITTokenGenerator.GetSHA256Hash(eventId.ToLower() + queueId + "3" + "idle" + issueTime, secretKey);
            var cookieValue = $"EventId={eventId}&QueueId={queueId}&{_FixedCookieValidityMinutesKey}=3&RedirectType=idle&IssueTime={issueTime}&Hash={hash}";

            var isCookieHttpOnly = true;
            var isCookieSecure   = true;

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();

            var fakeRequest = new KnownUserTest.MockHttpRequest
            {
                CookiesValue = new NameValueCollection {
                    { cookieKey, cookieValue }
                }
            };

            fakeContext.HttpRequest = fakeRequest;

            var fakeResponse = new KnownUserTest.MockHttpResponse();

            fakeContext.HttpResponse = fakeResponse;

            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            testObject.ReissueQueueCookie(eventId, 12, "testdomain", isCookieHttpOnly, isCookieSecure, secretKey);

            var newIssueTime = DateTimeHelper.GetDateTimeFromUnixTimeStamp(CookieHelper.ToNameValueCollectionFromValue(fakeResponse.CookiesValue[cookieKey]["cookieValue"].ToString())["IssueTime"]);

            Assert.True(newIssueTime.Subtract(DateTime.UtcNow) < TimeSpan.FromSeconds(2));
            Assert.True(fakeResponse.CookiesValue[cookieKey]["domain"].ToString() == "testdomain");
            Assert.Equal(isCookieHttpOnly, fakeResponse.CookiesValue[cookieKey]["isHttpOnly"] as bool?);
            Assert.Equal(isCookieSecure, fakeResponse.CookiesValue[cookieKey]["isSecure"] as bool?);

            var state = testObject.GetState(eventId, 5, secretKey);

            Assert.True(state.IsValid);
            Assert.True(!state.IsStateExtendable);
            Assert.True(state.QueueId == queueId);
            Assert.True(state.RedirectType == "idle");
        }
        public void Store_GetState_TamperedCookie_StateIsNotValid_EventId()
        {
            var eventId          = "event1";
            var secretKey        = "4e1db821-a825-49da-acd0-5d376f2068db";
            var cookieDomain     = ".test.com";
            var isCookieHttpOnly = true;
            var isCookieSecure   = true;
            var queueId          = "f8757c2d-34c2-4639-bef2-1736cdd30bbb";
            var cookieValidity   = 10;
            var cookieKey        = UserInQueueStateCookieRepository.GetCookieKey(eventId);

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeResponse = new KnownUserTest.MockHttpResponse
            {
            };

            fakeContext.HttpResponse = fakeResponse;

            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            testObject.Store(eventId, queueId, 3, cookieDomain, isCookieHttpOnly, isCookieSecure, "idle", secretKey);
            var cookieValue  = fakeResponse.CookiesValue[cookieKey]["cookieValue"].ToString();
            var cookieValues = CookieHelper.ToNameValueCollectionFromValue(cookieValue);

            Assert.True(((DateTime)fakeResponse.CookiesValue[cookieKey]["expiration"]).Subtract(DateTime.UtcNow.AddDays(1)) < TimeSpan.FromMinutes(1));
            Assert.True(fakeResponse.CookiesValue[cookieKey]["domain"].ToString() == cookieDomain);

            //Retrive

            var tamperedCookie = cookieValue.Replace("EventId", "EventId2");
            var fakeRequest    = new KnownUserTest.MockHttpRequest
            {
                CookiesValue = new NameValueCollection {
                    { cookieKey, tamperedCookie }
                }
            };

            fakeContext.HttpRequest = fakeRequest;

            var state = testObject.GetState(eventId, cookieValidity, secretKey);

            Assert.False(state.IsValid);
            Assert.False(state.IsStateExtendable);
            Assert.True(String.IsNullOrEmpty(state.QueueId));
            Assert.True(String.IsNullOrEmpty(state.RedirectType));
        }
        public void Store_GetState_ExpiredCookie_StateIsNotValid()
        {
            var eventId      = "event1";
            var secretKey    = "secretKey";
            var cookieDomain = ".test.com";
            var queueId      = "f8757c2d-34c2-4639-bef2-1736cdd30bbb";
            var cookieKey    = UserInQueueStateCookieRepository.GetCookieKey(eventId);

            var cookieValidity = -1;

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeResponse = new KnownUserTest.MockHttpResponse()
            {
            };

            fakeContext.HttpResponse = fakeResponse;

            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            testObject.Store(eventId, queueId, null, cookieDomain, "idle", secretKey);
            var cookieValue  = fakeResponse.CookiesValue[cookieKey]["cookieValue"].ToString();
            var cookieValues = CookieHelper.ToNameValueCollectionFromValue(cookieValue);

            Assert.True(((DateTime)fakeResponse.CookiesValue[cookieKey]["expiration"]).Subtract(DateTime.UtcNow.AddDays(1)) < TimeSpan.FromMinutes(1));
            Assert.True(fakeResponse.CookiesValue[cookieKey]["domain"].ToString() == cookieDomain);

            //retrive
            var fakeRequest = new KnownUserTest.MockHttpRequest()
            {
                CookiesValue = new NameValueCollection()
                {
                    { cookieKey, cookieValue }
                }
            };

            fakeContext.HttpRequest = fakeRequest;

            var state = testObject.GetState(eventId, cookieValidity, secretKey);

            Assert.False(state.IsValid);
            Assert.False(state.IsStateExtendable);
            Assert.True(String.IsNullOrEmpty(state.QueueId));
            Assert.True(String.IsNullOrEmpty(state.RedirectType));
        }
Beispiel #15
0
        public void GetState_ValidCookieFormat_Extendable()
        {
            var eventId   = "event1";
            var secretKey = "4e1db821-a825-49da-acd0-5d376f2068db";

            var queueId   = "f8757c2d-34c2-4639-bef2-1736cdd30bbb";
            var cookieKey = UserInQueueStateCookieRepository.GetCookieKey(eventId);



            var issueTime = DateTimeHelper.GetUnixTimeStampFromDate(DateTime.UtcNow);
            var hash      = QueueITTokenGenerator.GetSHA256Hash(eventId.ToLower() + queueId + "queue" + issueTime.ToString(),
                                                                secretKey);
            var cookieValue = $"EventId={eventId}&QueueId={queueId}&RedirectType=queue&IssueTime={issueTime}&Hash={hash}";

            KnownUserTest.HttpContextMock fakeContext = new KnownUserTest.HttpContextMock();
            var fakeRequest = new KnownUserTest.MockHttpRequest()
            {
                CookiesValue = new NameValueCollection()
                {
                    { cookieKey, cookieValue }
                }
            };

            fakeContext.HttpRequest = fakeRequest;
            var fakeResponse = new KnownUserTest.MockHttpResponse()
            {
            };

            fakeContext.HttpResponse = fakeResponse;


            var testObject = new UserInQueueStateCookieRepository(fakeContext);

            var state = testObject.GetState(eventId, 10, secretKey);

            Assert.True(state.IsStateExtendable);
            Assert.True(state.IsValid);
            Assert.True(state.IsFound);
            Assert.True(state.QueueId == queueId);
            Assert.True(state.RedirectType == "queue");
        }
Beispiel #16
0
        public void GetMatchedIntegrationConfig_ThreeIntegrationsInOrder_SecondMatched()
        {
            var testObject          = new IntegrationEvaluator();
            var customerIntegration = new CustomerIntegration
            {
                Integrations = new List <IntegrationConfigModel>
                {
                    new IntegrationConfigModel
                    {
                        Name     = "integration0",
                        Triggers = new List <TriggerModel>
                        {
                            new TriggerModel
                            {
                                LogicalOperator = LogicalOperatorType.And,
                                TriggerParts    = new List <TriggerPart>
                                {
                                    new TriggerPart
                                    {
                                        CookieName     = "c1",
                                        Operator       = ComparisonOperatorType.EqualS,
                                        ValueToCompare = "value1",
                                        ValidatorType  = ValidatorType.CookieValidator
                                    }
                                }
                            }
                        }
                    },
                    new IntegrationConfigModel
                    {
                        Name     = "integration1",
                        Triggers = new List <TriggerModel>
                        {
                            new TriggerModel
                            {
                                LogicalOperator = LogicalOperatorType.And,
                                TriggerParts    = new List <TriggerPart>
                                {
                                    new TriggerPart
                                    {
                                        CookieName     = "c1",
                                        Operator       = ComparisonOperatorType.EqualS,
                                        ValueToCompare = "Value1",
                                        ValidatorType  = ValidatorType.CookieValidator
                                    }
                                }
                            }
                        }
                    },
                    new IntegrationConfigModel
                    {
                        Name     = "integration2",
                        Triggers = new List <TriggerModel>
                        {
                            new TriggerModel
                            {
                                LogicalOperator = LogicalOperatorType.And,
                                TriggerParts    = new List <TriggerPart>
                                {
                                    new TriggerPart
                                    {
                                        UrlPart  = UrlPartType.PageUrl,
                                        Operator = ComparisonOperatorType.Contains,

                                        ValueToCompare = "test",
                                        ValidatorType  = ValidatorType.UrlValidator
                                    }
                                }
                            }
                        }
                    }
                }
            };

            var url = new Uri("http://test.tesdomain.com:8080/test?q=2");

            var httpRequestMock = new KnownUserTest.MockHttpRequest
            {
                CookiesValue = new NameValueCollection {
                    { "c1", "Value1" }
                }
            };

            Assert.False(testObject.GetMatchedIntegrationConfig(customerIntegration, url.AbsoluteUri, httpRequestMock).Name == "integration2");
        }