public void TestAssertWithNoItem()
        {
            // Arrange
            var key   = fixture.Create <string>();
            var value = fixture.Create <string>();
            var item  = new HeaderAssertion {
                Key = key, Value = value
            };
            var arrange = new Arrange
            {
                HttpResponse = new HttpResponse
                {
                    Headers = new NameValueCollection
                    {
                        { "a", "a value" },
                        { "b", "b value" },
                    }
                },
            };

            // Act
            item.Assert(null, arrange);

            // Assert
            Assert.IsFalse(item.Success);
        }
        public void TestName()
        {
            // Arrange
            var key  = fixture.Create <string>();
            var item = new HeaderAssertion {
                Key = key
            };

            // Act & Assert
            Assert.AreEqual("Headers(" + key + ")", item.Name);
        }
 private static HeaderAssertion WithValueComparer(this HeaderAssertion assertion, Func <IEnumerable <string>, bool> compare, string message)
 {
     assertion.Assertion.Should(response =>
     {
         var header = response.GetHeaderValues(assertion.Name);
         if (!compare(header))
         {
             throw new SolidTestingAssertionException(message);
         }
     });
     return(assertion);
 }
 /// <summary>
 /// Asserts whether the header ends with a specified value
 /// </summary>
 /// <param name="assertion">The header assertion</param>
 /// <param name="value">The value the header should end with</param>
 /// <param name="comparison">A comparison to use for the header value</param>
 /// <returns>A header assertion</returns>
 public static HeaderAssertion WithValueEndingWith(this HeaderAssertion assertion, string value, StringComparison comparison)
 {
     return(assertion.WithValueComparer(values => values.Any(v => v.EndsWith(value, comparison)), $"Expected value starting with '{value}' not found."));
 }
 /// <summary>
 /// Asserts whether the header ends with a specified value
 /// </summary>
 /// <param name="assertion">The header assertion</param>
 /// <param name="value">The value the header should end with</param>
 /// <returns>A header assertion</returns>
 public static HeaderAssertion WithValueEndingWith(this HeaderAssertion assertion, string value)
 {
     return(assertion.WithValueEndingWith(value, StringComparison.Ordinal));
 }
 /// <summary>
 /// Asserts whether the header has a specified value
 /// </summary>
 /// <param name="assertion">The header assertion</param>
 /// <param name="value">The header value</param>
 /// <param name="comparer">An equality comparer to use for the header value</param>
 /// <returns>A header assertion</returns>
 public static HeaderAssertion WithValue(this HeaderAssertion assertion, string value, IEqualityComparer <string> comparer)
 {
     return(assertion.WithValueComparer(values => values.Contains(value, comparer), $"Expected value '{value}' not found."));
 }