public void CreatesHttpWebRequestWithPostMethod()
            {
                var        transmission = new TestableTransmission();
                WebRequest request      = transmission.TestableCreateRequest(new Uri("http://uri"));

                Assert.Equal("POST", request.Method);
            }
            public void CreatesHttpWebRequestWithoutContentTypeIfNotSpecifiedInConstructor()
            {
                var        transmission = new TestableTransmission(contentType: string.Empty);
                WebRequest request      = transmission.TestableCreateRequest(new Uri("http://uri"));

                Assert.Null(request.ContentType);
            }
            public void CreatesHttpWebRequestWithContentTypeSpecifiedInConstructor()
            {
                var        transmission = new TestableTransmission(contentType: "TestContentType");
                WebRequest request      = transmission.TestableCreateRequest(new Uri("http://uri"));

                Assert.Equal(transmission.ContentType, request.ContentType);
            }
            public void CreatesHttpWebRequestWithContentEncodingSpecifiedInConstructor()
            {
                var        transmission = new TestableTransmission(contentEncoding: "TestContentEncoding");
                WebRequest request      = transmission.TestableCreateRequest(new Uri("http://uri"));

                Assert.Equal(transmission.ContentEncoding, request.Headers[HttpRequestHeader.ContentEncoding]);
            }
            public void CreatesHttpWebRequestWithContentLengthCalculatedFromDataSpecifiedInConstructor()
            {
                byte[]     content      = Encoding.UTF8.GetBytes("custom data");
                var        transmission = new TestableTransmission(new Uri("http://test.uri"), content);
                WebRequest request      = transmission.TestableCreateRequest(new Uri("http://uri"));

                Assert.Equal(content.Length, request.ContentLength);
            }
            public void CreatesHttpWebRequestWithSpecifiedUri()
            {
                var transmission = new TestableTransmission();

                var        expectedUri = new Uri("http://custom.uri");
                WebRequest request     = transmission.TestableCreateRequest(expectedUri);

                Assert.Equal(expectedUri, request.RequestUri);
            }
示例#7
0
 public void ThrowsInvalidOperationExceptionWhenTransmissionIsAlreadySending()
 {
     AsyncTest.Run(async() =>
     {
         var transmission         = new TestableTransmission();
         FieldInfo isSendingField = typeof(Transmission).GetField("isSending", BindingFlags.NonPublic | BindingFlags.Instance);
         isSendingField.SetValue(transmission, 1, BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Instance, null, null);
         await AssertEx.ThrowsAsync <InvalidOperationException>(() => transmission.SendAsync());
     });
 }
            public void ThrowsInvalidOperationExceptionWhenTransmissionIsAlreadySending()
            {
                AsyncTest.Run(async() =>
                {
                    var request = new StubWebRequest();
                    request.OnBeginGetRequestStream = (callback, state) => TaskEx.Delay(TimeSpan.FromMilliseconds(10)).AsAsyncResult(callback, request);

                    var transmission             = new TestableTransmission();
                    transmission.OnCreateRequest = uri => request;

                    Task dontWait = transmission.SendAsync();
                    await AssertEx.ThrowsAsync <InvalidOperationException>(() => transmission.SendAsync());
                });
            }
            public void AbortsWebRequestWhenBeginGetRequestStreamTimesOut()
            {
                var requestAborted = new ManualResetEventSlim();
                var finishBeginGetRequestStream = new ManualResetEventSlim();
                var request = new StubWebRequest();

                request.OnAbort = () => requestAborted.Set();
                request.OnBeginGetRequestStream = (callback, state) => TaskEx.Run(() => finishBeginGetRequestStream.Wait()).AsAsyncResult(callback, request);
                var transmission = new TestableTransmission(timeout: TimeSpan.FromTicks(1));

                transmission.OnCreateRequest = uri => request;

                Task sendAsync = transmission.SendAsync();

                Assert.True(requestAborted.Wait(1000));
                finishBeginGetRequestStream.Set();
            }
            public void WritesTransmissionContentToRequestStream()
            {
                AsyncTest.Run(async() =>
                {
                    var requestStream = new MemoryStream();

                    var request = new StubWebRequest();
                    request.OnEndGetRequestStream = asyncResult => requestStream;

                    byte[] transmissionContent   = new byte[] { 1, 2, 3, 4, 5 };
                    var transmission             = new TestableTransmission(new Uri("http://test.uri"), transmissionContent);
                    transmission.OnCreateRequest = uri => request;

                    await transmission.SendAsync();

                    Assert.Equal(transmissionContent, requestStream.ToArray());
                });
            }
            public void DoesNotAbortRequestThatWasSentSuccessfully()
            {
                AsyncTest.Run(async() =>
                {
                    bool requestAborted = false;
                    var request         = new StubWebRequest {
                        OnAbort = () => requestAborted = true
                    };

                    var transmission             = new TestableTransmission(timeout: TimeSpan.FromMilliseconds(50));
                    transmission.OnCreateRequest = uri => request;

                    await transmission.SendAsync();

                    await TaskEx.Delay(50); // Let timout detector finish

                    Assert.False(requestAborted);
                });
            }
            public void DisposesHttpWebResponseToReleaseResources()
            {
                AsyncTest.Run(async() =>
                {
                    bool responseDisposed = false;
                    var response          = new StubWebResponse {
                        OnDispose = () => responseDisposed = true
                    };
                    var request = new StubWebRequest {
                        OnEndGetResponse = asyncResult => response
                    };
                    var transmission = new TestableTransmission {
                        OnCreateRequest = uri => request
                    };

                    await transmission.SendAsync();

                    Assert.True(responseDisposed);
                });
            }
            public void BeginsAsynchronouslyGettingRequestStream()
            {
                AsyncTest.Run(async() =>
                {
                    int beginGetRequestStreamCount = 0;
                    var request = new StubWebRequest();
                    request.OnBeginGetRequestStream = (callback, state) =>
                    {
                        beginGetRequestStreamCount++;
                        return(TaskEx.FromResult <object>(null).AsAsyncResult(callback, request));
                    };

                    var transmission = new TestableTransmission {
                        OnCreateRequest = uri => request
                    };

                    await transmission.SendAsync();

                    Assert.Equal(1, beginGetRequestStreamCount);
                });
            }
            public void AsynchronouslyFinishesGettingResponse()
            {
                AsyncTest.Run(async() =>
                {
                    int endGetResponseCount  = 0;
                    var request              = new StubWebRequest();
                    request.OnEndGetResponse = asyncResult =>
                    {
                        endGetResponseCount++;
                        return(new StubWebResponse());
                    };

                    var transmission = new TestableTransmission {
                        OnCreateRequest = uri => request
                    };

                    await transmission.SendAsync();

                    Assert.Equal(1, endGetResponseCount);
                });
            }
            public void CreatesHttpWebRequestWithSpecifiedUri()
            {
                var transmission = new TestableTransmission();

                var expectedUri = new Uri("http://custom.uri");
                WebRequest request = transmission.TestableCreateRequest(expectedUri);

                Assert.Equal(expectedUri, request.RequestUri);
            }
 public void CreatesHttpWebRequestWithContentTypeSpecifiedInConstructor()
 {
     var transmission = new TestableTransmission(contentType: "TestContentType");
     WebRequest request = transmission.TestableCreateRequest(new Uri("http://uri"));
     Assert.Equal(transmission.ContentType, request.ContentType);
 }
 public void CreatesHttpWebRequestWithoutContentTypeIfNotSpecifiedInConstructor()
 {
     var transmission = new TestableTransmission(contentType: string.Empty);
     WebRequest request = transmission.TestableCreateRequest(new Uri("http://uri"));
     Assert.Null(request.ContentType);
 }
 public void CreatesHttpWebRequestWithContentEncodingSpecifiedInConstructor()
 {
     var transmission = new TestableTransmission(contentEncoding: "TestContentEncoding");
     WebRequest request = transmission.TestableCreateRequest(new Uri("http://uri"));
     Assert.Equal(transmission.ContentEncoding, request.Headers[HttpRequestHeader.ContentEncoding]);
 }
     public void ThrowsInvalidOperationExceptionWhenTransmissionIsAlreadySending()
     {
         AsyncTest.Run(async () =>
         {
             var request = new StubWebRequest();
             request.OnBeginGetRequestStream = (callback, state) => TaskEx.Delay(TimeSpan.FromMilliseconds(10)).AsAsyncResult(callback, request);
 
             var transmission = new TestableTransmission();
             transmission.OnCreateRequest = uri => request;
 
             Task dontWait = transmission.SendAsync();
             await AssertEx.ThrowsAsync<InvalidOperationException>(() => transmission.SendAsync());
         });
     }
 public void CreatesHttpWebRequestWithContentLengthCalculatedFromDataSpecifiedInConstructor()
 {
     byte[] content = Encoding.UTF8.GetBytes("custom data");
     var transmission = new TestableTransmission(new Uri("http://test.uri"), content);
     WebRequest request = transmission.TestableCreateRequest(new Uri("http://uri"));
     Assert.Equal(content.Length, request.ContentLength);
 }
     public void WritesTransmissionContentToRequestStream()
     {
         AsyncTest.Run(async () =>
         {
             var requestStream = new MemoryStream();
 
             var request = new StubWebRequest();
             request.OnEndGetRequestStream = asyncResult => requestStream;
 
             byte[] transmissionContent = new byte[] { 1, 2, 3, 4, 5 };
             var transmission = new TestableTransmission(new Uri("http://test.uri"), transmissionContent);
             transmission.OnCreateRequest = uri => request;
 
             await transmission.SendAsync();
 
             Assert.Equal(transmissionContent, requestStream.ToArray());
         });
     }
     public void BeginsAsynchronouslyGettingRequestStream()
     {
         AsyncTest.Run(async () =>
         {
             int beginGetRequestStreamCount = 0;
             var request = new StubWebRequest();
             request.OnBeginGetRequestStream = (callback, state) =>
             {
                 beginGetRequestStreamCount++;
                 return TaskEx.FromResult<object>(null).AsAsyncResult(callback, request);
             };
 
             var transmission = new TestableTransmission { OnCreateRequest = uri => request };
 
             await transmission.SendAsync();
 
             Assert.Equal(1, beginGetRequestStreamCount);
         });
     }
     public void AsynchronouslyFinishesGettingResponse()
     {
         AsyncTest.Run(async () =>
         {
             int endGetResponseCount = 0;
             var request = new StubWebRequest();
             request.OnEndGetResponse = asyncResult =>
             {
                 endGetResponseCount++;
                 return new StubWebResponse();
             };
 
             var transmission = new TestableTransmission { OnCreateRequest = uri => request };
 
             await transmission.SendAsync();
 
             Assert.Equal(1, endGetResponseCount);
         });
     }
     public void DisposesHttpWebResponseToReleaseResources()
     {
         AsyncTest.Run(async () =>
         {
             bool responseDisposed = false;
             var response = new StubWebResponse { OnDispose = () => responseDisposed = true };
             var request = new StubWebRequest { OnEndGetResponse = asyncResult => response };
             var transmission = new TestableTransmission { OnCreateRequest = uri => request };
 
             await transmission.SendAsync();
 
             Assert.True(responseDisposed);
         });
     }
 public void CreatesHttpWebRequestWithPostMethod()
 {
     var transmission = new TestableTransmission();
     WebRequest request = transmission.TestableCreateRequest(new Uri("http://uri"));
     Assert.Equal("POST", request.Method);
 }
     public void DoesNotAbortRequestThatWasSentSuccessfully()
     {
         AsyncTest.Run(async () =>
         {
             bool requestAborted = false;
             var request = new StubWebRequest { OnAbort = () => requestAborted = true };
 
             var transmission = new TestableTransmission(timeout: TimeSpan.FromMilliseconds(50));
             transmission.OnCreateRequest = uri => request;
 
             await transmission.SendAsync();
 
             await TaskEx.Delay(50); // Let timout detector finish
 
             Assert.False(requestAborted);
         });
     }
            public void AbortsWebRequestWhenBeginGetRequestStreamTimesOut()
            {
                var requestAborted = new ManualResetEventSlim();
                var finishBeginGetRequestStream = new ManualResetEventSlim();
                var request = new StubWebRequest();
                request.OnAbort = () => requestAborted.Set();
                request.OnBeginGetRequestStream = (callback, state) => TaskEx.Run(() => finishBeginGetRequestStream.Wait()).AsAsyncResult(callback, request);
                var transmission = new TestableTransmission(timeout: TimeSpan.FromTicks(1));
                transmission.OnCreateRequest = uri => request;

                Task sendAsync = transmission.SendAsync();

                Assert.True(requestAborted.Wait(1000));
                finishBeginGetRequestStream.Set();
            }