public void MatchNegative_should_not_match_text_that_is_not_in_content()
        {
            // Arrange
            var sessionVariables = new SessionVariables();
            var matcher = new VerificationsMatcher(sessionVariables);

            var verifications = new List<VerificationItem>();
            verifications.Add(new VerificationItem("desc1", "this isnt in the text", VerifyType.Negative));
            verifications.Add(new VerificationItem("desc2", "content here", VerifyType.Negative));

            string content = "<p>Some content here</p>";

            // Act
            List<VerificationItem> results = matcher.MatchNegative(verifications, content);

            // Assert
            Assert.That(results.Count, Is.EqualTo(2));
            Assert.That(results[0].Success, Is.True);
            Assert.That(results[0].Description, Is.EqualTo("desc1"));
            Assert.That(results[0].Regex, Is.EqualTo("this isnt in the text"));

            Assert.That(results[1].Success, Is.False);
            Assert.That(results[1].Description, Is.EqualTo("desc2"));
            Assert.That(results[1].Regex, Is.EqualTo("content here"));
        }
        public void MatchNegative_should_return_veriftype_positives_in_list()
        {
            // Arrange
            var sessionVariables = new SessionVariables();
            var matcher = new VerificationsMatcher(sessionVariables);

            var verifications = new List<VerificationItem>();
            verifications.Add(new VerificationItem("p1", "a regex", VerifyType.Positive));
            verifications.Add(new VerificationItem("p2", "another regex", VerifyType.Positive));
            verifications.Add(new VerificationItem("n1", "one more regex", VerifyType.Negative));

            string content = "<p>whatever</p>";

            // Act
            List<VerificationItem> results = matcher.MatchNegative(verifications, content);

            // Assert
            Assert.That(results.Count, Is.EqualTo(3));
        }
Esempio n. 3
0
        internal TestCaseResult RunCase(Case testCase, SessionVariables variables, VerificationsMatcher verificationMatcher)
        {
            var testResult = new TestCaseResult();
            testResult.TestCase = testCase;

            try
            {
                string resolvedUrl = variables.ReplacePlainTextVariablesIn(testCase.Url);
                testResult.ActualUrl = resolvedUrl;

                HttpResponse response = _httpClient.ExecuteRequest(testCase.Method, resolvedUrl, testCase.PostType, testCase.PostBody, testCase.Headers);
                testResult.ResponseTime = response.ResponseTime;
                testResult.HttpResponse = response;

                if (response.StatusCode == testCase.VerifyResponseCode)
                {
                    testResult.ResponseCodeSuccess = true;
                    string content = response.ToString();

                    // Put the parseresponse regex values in the current variable set
                    Dictionary<string, string> parsedVariables = ParseResponseMatcher.MatchParseResponses(testCase.ParseResponses, content);
                    variables.AddOrUpdateVariables(parsedVariables);

                    // Verify positives
                    testResult.VerifyPositiveResults = verificationMatcher.MatchPositive(testCase.VerifyPositives, content);

                    // Verify Negatives
                    testResult.VerifyNegativeResults = verificationMatcher.MatchNegative(testCase.VerifyNegatives, content);
                }
                else
                {
                    testResult.ResponseCodeSuccess = false;
                }

                if (testResult.Success == false)
                {
                    testResult.Message = testCase.ErrorMessage;
                }

                if (ShouldLogRequest(testResult, testCase))
                {
                    _httpClient.LogLastRequest();
                }

                if (ShouldLogResponse(testResult, testCase))
                {
                    _httpClient.LogLastResponse();
                }

                _resultWriter.Write(testResult);

                if (testCase.Sleep > 0)
                    Thread.Sleep(testCase.Sleep * 1000);
            }
            catch (Exception ex)
            {
                testResult.ResponseCodeSuccess = false;
                testResult.ExceptionMessage = ex.Message;
            }

            return testResult;
        }