public void GetHttpHeaderValue_HttpRequestHeaderStringFound_HeaderValue()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headerDefaultValue = "Unknown User Agent";
            var headerValue = "Talifun Browser";
            var headerType = HttpRequestHeader.UserAgent;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);
   
            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var userAgentValue = httpRequestHeaderHelper.GetHttpHeaderValue(httpRequest, headerName, headerDefaultValue);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.AreEqual(headerValue, userAgentValue);
        }
        public void CheckIfMatch_HasNoIfMatchHeader_Null()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var entityTag = "1234567";
            var doesEntityExists = true;
            var headerValue = string.Empty;
            var headerType = HttpRequestHeader.IfMatch;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var ifMatchSatisfied = httpRequestHeaderHelper.CheckIfMatch(httpRequest, entityTag, doesEntityExists);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.IsNull(ifMatchSatisfied);
        }
        public static HttpClient ConstructHttpClient(string proxyUrl, string baseAddress = null,
                                                     HttpRequestHeaderHelper headers     = null, TimeSpan?timeout = null)
        {
            var handler = new HttpClientHandler();

            if (string.IsNullOrWhiteSpace(proxyUrl) == false)
            {
                handler.Proxy    = new WebProxy(proxyUrl);
                handler.UseProxy = true;
            }

            var client = new HttpClient(handler)
            {
                Timeout = timeout ?? TimeSpan.FromMilliseconds(300000)
            };

            if (string.IsNullOrWhiteSpace(baseAddress) == false)
            {
                client.BaseAddress = new Uri(baseAddress);
            }

            if (headers == null)
            {
                return(client);
            }

            foreach (var pair in headers.GetHeaderValues())
            {
                if (pair.Value != null)
                {
                    client.DefaultRequestHeaders.TryAddWithoutValidation(pair.Key, pair.Value);
                }
            }

            return(client);
        } /*End of ConstructHttpClient method*/
        public void CheckIfNoneMatch_MatchingWildCardAndEntityDoesNotExist_True()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var entityTag = "abcdef";
            var doesEntityExists = false;
            var headerValue = "*";
            var headerType = HttpRequestHeader.IfNoneMatch;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var ifMatchSatisfied = httpRequestHeaderHelper.CheckIfNoneMatch(httpRequest, entityTag, doesEntityExists);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.IsNotNull(ifMatchSatisfied);
            Assert.IsTrue(ifMatchSatisfied.Value);
        }
        public void IsRangeRequest_HasRangeHeader_True()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headerValue = "bytes=500-600,601-999";
            var headerType = HttpRequestHeader.Range;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var isRangeRequest = httpRequestHeaderHelper.IsRangeRequest(httpRequest);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.True(isRangeRequest);
        }
        public void IsRangeRequest_DoesNotHaveRangeHeader_False()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headerValue = string.Empty;
            var headerType = HttpRequestHeader.Range;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var isRangeRequest = httpRequestHeaderHelper.IsRangeRequest(httpRequest);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.False(isRangeRequest);
        }
        public void GetRanges_StartRangeLargerThenEntityLength_False()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var contentLength = 10000;
            var headerValue = "bytes=20000-";
            var headerType = HttpRequestHeader.Range;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            IEnumerable<RangeItem> ranges;
            var rangeResult = httpRequestHeaderHelper.GetRanges(httpRequest, contentLength, out ranges);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.NotNull(rangeResult);
            Assert.IsFalse(rangeResult.Value);
            Assert.IsNull(ranges);
        }
        public void CheckUnlessModifiedSince_HasNotBeenModifiedSince_True()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var lastModified = new DateTime(2010, 01, 01, 01, 01, 01);
            var headerValue = lastModified.AddSeconds(1).ToString("r");
            var headerType = HttpRequestHeader.UnlessModifiedSince;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var hasNotBeenModifiedSince = httpRequestHeaderHelper.CheckUnlessModifiedSince(httpRequest, lastModified);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.IsNotNull(hasNotBeenModifiedSince);
            Assert.True(hasNotBeenModifiedSince.Value);
        }
        public void GetHttpHeaderWithQValues_NoHttpHeaderQValues_EmptyList()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headerValue = string.Empty;
            var headerType = HttpRequestHeader.AcceptEncoding;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var headerValueWithQValues = httpRequestHeaderHelper.GetHttpHeaderWithQValues(httpRequest, headerType);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.IsEmpty(headerValueWithQValues);
        }
        public void GetHttpHeaderWithQValues_MultipleHttpHeaderWithQValueSet_List()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var identity1 = "gzip";
            var qValue1 = 0.5f;

            var identity2 = "deflate";
            var qValue2 = 0.8f;

            var headerValue = identity1 + ";q=" + qValue1.ToString("N1") + "," + identity2 + ";q=" + qValue2.ToString("N1");
            var headerType = HttpRequestHeader.AcceptEncoding;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var headerValueWithQValues = httpRequestHeaderHelper.GetHttpHeaderWithQValues(httpRequest, headerType);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.AreEqual(2, headerValueWithQValues.Count);

            Assert.AreEqual(identity1, headerValueWithQValues[0].Identity);
            Assert.IsNotNull(headerValueWithQValues[0].QValue);
            Assert.AreEqual(qValue1, headerValueWithQValues[0].QValue.Value);

            Assert.AreEqual(identity2, headerValueWithQValues[1].Identity);
            Assert.IsNotNull(headerValueWithQValues[1].QValue);
            Assert.AreEqual(qValue2, headerValueWithQValues[1].QValue.Value);
        }
        public void GetHttpHeaderWithQValues_IsCaseSensitive_List()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headerValue = "abcdeF";
            var headerType = HttpRequestHeader.AcceptEncoding;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var headerValueWithQValues = httpRequestHeaderHelper.GetHttpHeaderWithQValues(httpRequest, headerType);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.AreEqual(1, headerValueWithQValues.Count);
            Assert.AreEqual(headerValue, headerValueWithQValues[0].Identity);
            Assert.IsNull(headerValueWithQValues[0].QValue);
        }
        public void GetHttpHeaderWithQValues_InvalidQValueNotANumber_List()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headerValue = "gzip, deflate, x-gzip, identity; q=moo";
            var headerType = HttpRequestHeader.AcceptEncoding;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var headerValueWithQValues = httpRequestHeaderHelper.GetHttpHeaderWithQValues(httpRequest, headerType);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.AreEqual(5, headerValueWithQValues.Count);
            Assert.AreEqual("identity", headerValueWithQValues[3].Identity);
            Assert.IsNull(headerValueWithQValues[3].QValue);
            Assert.AreEqual("q=moo", headerValueWithQValues[4].Identity);
            Assert.IsNull(headerValueWithQValues[4].QValue);
        }
        public void GetHttpHeaderValues_MultipleHttpHeaderWithValuesSetWithSpacing_List()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var identity1 = "gzip";
            var identity2 = "deflate";
            var headerValue = identity1 + " , " + identity2;
            var headerType = HttpRequestHeader.IfMatch;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var headerValues = httpRequestHeaderHelper.GetHttpHeaderValues(httpRequest, headerType);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.AreEqual(2, headerValues.Count);
            Assert.AreEqual(identity1, headerValues[0]);
            Assert.AreEqual(identity2, headerValues[1]);
        }
        public void GetHttpHeaderValues_HttpHeaderWithOneValueSet_List()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headerValue = "1234567";
            var headerType = HttpRequestHeader.IfMatch;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var headerValues = httpRequestHeaderHelper.GetHttpHeaderValues(httpRequest, headerType);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.AreEqual(1, headerValues.Count);
            Assert.AreEqual(headerValue.ToLowerInvariant(), headerValues[0]);
        }
        public void CheckIfModifiedSince_DateModifiedSinceInvalid_False()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var lastModified = new DateTime(2010, 01, 01, 01, 01, 01, DateTimeKind.Utc);
            var headerValue = "invalid";
            var headerType = HttpRequestHeader.IfModifiedSince;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var hasBeenModifiedSince = httpRequestHeaderHelper.CheckIfModifiedSince(httpRequest, lastModified);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.IsNull(hasBeenModifiedSince);
        }
        public void CheckIfRange_CheckOnLastModifiedIfRangeHeader_True()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headers = MockRepository.GenerateMock<NameValueCollection>();
            httpRequest.Stub(x => x.Headers).Return(headers);

            var lastModified = new DateTime(2010, 01, 01, 01, 01, 01);
            var etag = "1234567";

            var rangeRequestHeaderValue = "bytes=500-600,601-999";
            var rangeRequestHeaderType = HttpRequestHeader.Range;
            var rangeRequestHeaderName = (string)rangeRequestHeaderType;

            var ifRangeHeaderValue = lastModified.ToString("r");
            var ifRangeHeaderType = HttpRequestHeader.IfRange;
            var ifRangeHeaderName = (string)ifRangeHeaderType;

            httpRequest.Headers.Expect(x => x[rangeRequestHeaderName]).Return(rangeRequestHeaderValue);
            httpRequest.Headers.Expect(x => x[ifRangeHeaderName]).Return(ifRangeHeaderValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var satisfiesRangeCheck = httpRequestHeaderHelper.CheckIfRange(httpRequest, etag, lastModified);

            //Assert
            headers.VerifyAllExpectations();
            httpRequest.VerifyAllExpectations();
            Assert.IsNotNull(satisfiesRangeCheck);
            Assert.True(satisfiesRangeCheck.Value);
        }
        public void CheckIfRange_NoRangeHeader_Null()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headers = MockRepository.GenerateMock<NameValueCollection>();
            httpRequest.Stub(x => x.Headers).Return(headers);
            var lastModified = new DateTime(2010, 01, 01, 01, 01, 01);
            var etag = "1234567";
            var headerValue = string.Empty;
            var headerType = HttpRequestHeader.Range;
            var headerName = (string)headerType;

            httpRequest.Headers.Expect(x => x[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var satisfiesRangeCheck = httpRequestHeaderHelper.CheckIfRange(httpRequest, etag, lastModified);

            //Assert
            headers.VerifyAllExpectations();
            httpRequest.VerifyAllExpectations();
            Assert.IsNull(satisfiesRangeCheck);
        }
        public void GetHttpMethod_GetRequest_Get()
        {
            //Arrange
            var httpMethodType = HttpMethod.Get;
            var httpMethodValue = (string)httpMethodType;

            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            httpRequest.Expect(x => x.HttpMethod).Return(httpMethodValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var result = httpRequestHeaderHelper.GetHttpMethod(httpRequest);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.AreEqual(httpMethodType, result);
        }
        public void CheckIfUnmodifiedSince_HasNoIfModifiedSinceHeader_Null()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var lastModified = new DateTime(2010, 01, 01, 01, 01, 01);
            var headerValue = string.Empty;
            var headerType = HttpRequestHeader.IfUnmodifiedSince;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var hasNotBeenModifiedSince = httpRequestHeaderHelper.CheckIfUnmodifiedSince(httpRequest, lastModified);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.IsNull(hasNotBeenModifiedSince);
        }
        public void GetRanges_NoHeaderSent_Null()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var contentLength = 10000;
            var headerValue = string.Empty;
            var headerType = HttpRequestHeader.Range;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            IEnumerable<RangeItem> ranges;
            var rangeResult = httpRequestHeaderHelper.GetRanges(httpRequest, contentLength, out ranges);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.IsNull(rangeResult);
            Assert.IsNotNull(ranges);
            Assert.IsFalse(ranges.Any());
        }
        public void GetCompressionMode_WildcardAcceptEncoding_Deflate()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var headerValue = "*";
            var headerType = HttpRequestHeader.AcceptEncoding;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            var compressionMode = httpRequestHeaderHelper.GetCompressionMode(httpRequest);

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.AreEqual(ResponseCompressionType.Deflate, compressionMode);
        }
        public void GetRanges_Second500Bytes_True()
        {
            //Arrange
            var httpRequest = MockRepository.GenerateMock<HttpRequestBase>();
            var contentLength = 10000;
            var headerValue = "bytes=500-999";
            var headerType = HttpRequestHeader.Range;
            var headerName = (string)headerType;

            httpRequest.Expect(x => x.Headers[headerName]).Return(headerValue);

            //Act
            var httpRequestHeaderHelper = new HttpRequestHeaderHelper();
            IEnumerable<RangeItem> ranges;
            var rangeResult = httpRequestHeaderHelper.GetRanges(httpRequest, contentLength, out ranges);
            var rangeItem = ranges.First();

            //Assert
            httpRequest.VerifyAllExpectations();
            Assert.NotNull(rangeResult);
            Assert.IsTrue(rangeResult.Value);

            Assert.IsNotNull(ranges);
            Assert.IsTrue(ranges.Any());
            Assert.AreEqual(500, rangeItem.StartRange);
            Assert.AreEqual(999, rangeItem.EndRange);
        }