public void Download_Error_JsonResponse()
{
using (var service = new MockClientService())
{
var downloader = new MediaDownloader(service);
IList <IDownloadProgress> progressList = new List <IDownloadProgress>();
downloader.ProgressChanged += (p) =>
{
progressList.Add(p);
};
var outputStream = new MemoryStream();
downloader.Download(_httpPrefix + "BadRequestJson", outputStream);
var lastProgress = progressList.LastOrDefault();
Assert.Equal(DownloadStatus.Failed, lastProgress.Status);
GoogleApiException exception = (GoogleApiException)lastProgress.Exception;
Assert.Equal(HttpStatusCode.BadRequest, exception.HttpStatusCode);
// Just a smattering of checks - if these two pass, it's surely okay.
Assert.Equal(BadRequestError.Code, exception.Error.Code);
Assert.Equal(BadRequestError.Errors[0].Message, exception.Error.Errors[0].Message);
Assert.NotNull(exception.Error.ErrorResponseContent);
Assert.Contains(BadRequestError.Errors[0].Message, exception.Error.ErrorResponseContent);
}
}
public void TestUploadInMultipleChunks_Interception(
[CombinatorialValues(true, false)] bool knownSize,
[CombinatorialValues(100, 400, 1000)] int chunkSize,
[CombinatorialValues(true, false)] bool ignoreFirstUploadCall)
{
// One fewer interception call than server calls, as there's no initialization call.
var expectedInterceptionCount = (uploadLength + chunkSize - 1) / chunkSize;
using (var server = new MultiChunkServer(_server, ignoreFirstUploadCall: ignoreFirstUploadCall))
using (var service = new MockClientService(server.HttpPrefix))
{
var content = knownSize ? new MemoryStream(uploadTestBytes) : new UnknownSizeMemoryStream(uploadTestBytes);
var uploader = new TestResumableUpload(service, "MultiChunk", "POST", content, "text/plain", chunkSize);
int interceptionCount = 0;
MemoryStream interceptedBytes = new MemoryStream();
uploader.UploadStreamInterceptor = (buffer, offset, count) =>
{
interceptedBytes.Write(buffer, offset, count);
interceptionCount++;
};
var progress = uploader.Upload();
Assert.Equal(expectedInterceptionCount, interceptionCount);
Assert.Equal(uploadTestBytes, interceptedBytes.ToArray());
}
}
public void CreateRequestOnRequestContentLengthTest()
{
var service = new MockClientService();
var request =
(Request)
Request.CreateRequest(
service,
new MockClientServiceRequest
{
HttpMethod = "POST",
MethodName = "TestMethod",
RestPath = "https://example.com/test",
});
request.WithParameters("");
HttpWebRequest webRequest = (HttpWebRequest)request.CreateWebRequest((r) => { });
// Test that the header is set, even if no body is specified.
Assert.AreEqual("POST", webRequest.Method);
Assert.AreEqual(0, webRequest.ContentLength);
// The content-length field will be automatically set as soon as content is written into the
// request stream. We cannot test it here as writing to the request stream requires us to have
// a valid connection to the server.
}
public void TestUploadWithQueryAndPathParameters()
{
var stream = new MemoryStream(Encoding.UTF8.GetBytes(UploadTestData));
const int id = 123;
var handler = new SingleChunkMessageHandler()
{
PathParameters = "testPath/" + id.ToString(),
QueryParameters = "&queryA=valuea&queryB=VALUEB",
StreamLength = stream.Length
};
using (var service = new MockClientService(new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
}))
{
var upload = new MockResumableWithParameters(service, "testPath/{id}", "POST", stream, "text/plain")
{
id = id,
querya = "valuea",
queryb = "VALUEB",
};
upload.Upload();
Assert.That(handler.Calls, Is.EqualTo(2));
}
}
public void CreateOuterRequestContent_Test()
{
using (var service = new MockClientService("http://sample.com"))
{
var request1 = new TestClientServiceRequest(service, new MockRequest
{
ETag = "\"100\"",
Name = "Name1"
});
var request2 = new TestClientServiceRequest(service, new MockRequest
{
ETag = "\"200\"",
Name = "Name1-1"
});
var content = BatchRequest.CreateOuterRequestContent(new[] { request1, request2 }).Result;
var requestStr = content.ReadAsStringAsync().Result;
// Read the boundary.
string boundary = null;
using (var reader = new StreamReader(new MemoryStream(Encoding.UTF8.GetBytes(requestStr))))
{
var line = reader.ReadLine();
boundary = line.Substring(2);
}
Assert.AreEqual(ExpectedContentMessage.Replace("BOUNDARY", boundary), requestStr);
}
}
public async Task TestInitiatedResumableUpload(
[CombinatorialValues("", "text/plain")] string contentType)
{
using (var server = new SingleChunkServer(_server))
using (var service = new MockClientService(server.HttpPrefix))
{
var content = new MemoryStream(uploadTestBytes);
var tmpUploader = new TestResumableUpload(
service, "SingleChunk", "POST", content, contentType, uploadLength);
var uploadUri = await tmpUploader.InitiateSessionAsync();
var uploader = ResumableUpload.CreateFromUploadUri(uploadUri, content);
var progress = uploader.Upload();
Assert.Equal(2, server.Requests.Count);
var r0 = server.Requests[0];
Assert.Equal(contentType, r0.Headers["X-Upload-Content-Type"]);
Assert.Equal(uploadTestBytes.Length.ToString(), r0.Headers["X-Upload-Content-Length"]);
var r1 = server.Requests[1];
Assert.Equal(uploadPath, server.RemovePrefix(r1.Url.AbsolutePath));
Assert.Equal($"bytes 0-{uploadLength - 1}/{uploadLength}", r1.Headers["Content-Range"]);
Assert.Equal(UploadStatus.Completed, progress.Status);
Assert.Equal(uploadTestBytes.Length, progress.BytesSent);
}
}
/// <summary>
/// A subtest for testing ExecuteAsync when an exception is thrown while sending the request. This is tested
/// with and without back-off. If back-off handler is attached to the service's message handler, there should
/// be 3 tries (the default value of <seealso cref="ConfigurableMessageHandler.NumTries"/>) before the
/// operation fails.
/// </summary>
/// <param name="backOff">Indicates if back-off handler is attached to the service.</param>
private void SubtestExecuteAsync_ThrowException(bool backOff)
{
var handler = new MockMessageHandler(true);
var initializer = new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
};
// Configure the back-off behavior by the input.
initializer.DefaultExponentialBackOffPolicy = backOff ?
ExponentialBackOffPolicy.Exception : ExponentialBackOffPolicy.None;
using (var service = new MockClientService(initializer))
{
var request = new TestClientServiceRequest(service, "GET", null);
var task = request.ExecuteAsync();
try
{
var result = task.Result;
Assert.Fail("Exception should be thrown");
}
catch (AggregateException ex)
{
Assert.That(ex.InnerException, Is.AssignableFrom(typeof(InvalidOperationMockException)));
}
int calls = backOff ? service.HttpClient.MessageHandler.NumTries : 1;
Assert.That(handler.Calls, Is.EqualTo(calls));
}
}
/// <summary> Test helper to test a fail uploading by with the given server error.</summary>
private void SubtestChunkUploadFail(ServerError error)
{
int chunkSize = 100;
var payload = Encoding.UTF8.GetBytes(UploadTestData);
var handler = new MultipleChunksMessageHandler(true, error, payload.Length,
chunkSize, true);
using (var service = new MockClientService(new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
}))
{
var stream = new MemoryStream(payload);
var upload = new MockResumableUpload(service, stream, "text/plain");
upload.ChunkSize = chunkSize;
IUploadProgress lastProgressStatus = null;
upload.ProgressChanged += (p) =>
{
lastProgressStatus = p;
};
upload.Upload();
var exepctedCalls = MultipleChunksMessageHandler.ErrorOnCall +
service.HttpClient.MessageHandler.NumTries - 1;
Assert.That(handler.Calls, Is.EqualTo(exepctedCalls));
Assert.NotNull(lastProgressStatus);
Assert.NotNull(lastProgressStatus.Exception);
Assert.That(lastProgressStatus.Status, Is.EqualTo(UploadStatus.Failed));
}
}
public void TestInitiatedResumableUpload(
[Values("", "text/plain")] string contentType)
{
using (var server = new SingleChunkServer(_server))
using (var service = new MockClientService(server.HttpPrefix))
{
var content = new MemoryStream(uploadTestBytes);
var tmpUploader = new TestResumableUpload(
service, "SingleChunk", "POST", content, contentType, uploadLength);
Uri uploadUri = null;
tmpUploader.UploadSessionData += sessionData => {
uploadUri = sessionData.UploadUri;
// Throw an exception so the upload fails.
throw new Exception();
};
var progress = tmpUploader.Upload();
Assert.That(progress.Status, Is.EqualTo(UploadStatus.Failed));
var uploader = ResumableUpload.CreateFromUploadUri(uploadUri, content);
progress = uploader.Upload();
Assert.That(server.Requests.Count, Is.EqualTo(2));
var r0 = server.Requests[0];
Assert.That(r0.Headers["X-Upload-Content-Type"], Is.EqualTo(contentType));
Assert.That(r0.Headers["X-Upload-Content-Length"], Is.EqualTo(uploadTestBytes.Length.ToString()));
var r1 = server.Requests[1];
Assert.That(server.RemovePrefix(r1.Url.AbsolutePath), Is.EqualTo(uploadPath));
Assert.That(r1.Headers["Content-Range"], Is.EqualTo($"bytes 0-{uploadLength - 1}/{uploadLength}"));
Assert.That(progress.Status, Is.EqualTo(UploadStatus.Completed));
Assert.That(progress.BytesSent, Is.EqualTo(uploadTestBytes.Length));
}
}
public void TestChunkSize()
{
using (var service = new MockClientService(new BaseClientService.Initializer()))
{
var stream = new MemoryStream(Encoding.UTF8.GetBytes(UploadTestData));
var upload = new MockResumableUploadWithResponse <TestRequest, TestResponse>
(service, stream, "text/plain");
// Negative chunk size.
try
{
upload.ChunkSize = -1;
Assert.Fail();
}
catch (ArgumentOutOfRangeException)
{
// Expected.
}
// Less than the minimum.
try
{
upload.ChunkSize = MockResumableUpload.MinimumChunkSize - 1;
Assert.Fail();
}
catch (ArgumentOutOfRangeException)
{
// Expected.
}
// Valid chunk size.
upload.ChunkSize = MockResumableUpload.MinimumChunkSize;
upload.ChunkSize = MockResumableUpload.MinimumChunkSize * 2;
}
}
public void Download_Error()
{
var downloadUri = "http://www.sample.com?alt=media";
var chunkSize = 100;
// reset the steam
StreamContent.Position = 0;
var handler = new MultipleChunksMessageHandler();
handler.StatusCode = HttpStatusCode.BadRequest;
handler.ChunkSize = chunkSize;
handler.DownloadUri = new Uri(downloadUri);
using (var service = new MockClientService(new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
}))
{
var downloader = new MediaDownloader(service);
downloader.ChunkSize = chunkSize;
IList <IDownloadProgress> progressList = new List <IDownloadProgress>();
downloader.ProgressChanged += (p) =>
{
progressList.Add(p);
};
var outputStream = new MemoryStream();
downloader.Download(downloadUri, outputStream);
var lastProgress = progressList.LastOrDefault();
Assert.That(lastProgress.Status, Is.EqualTo(DownloadStatus.Failed));
}
}
public void ExecuteAsync_Error()
{
var handler = new ErrorMessageHanlder();
var initializer = new BaseClientService.Initializer
{
HttpClientFactory = new MockHttpClientFactory(handler)
};
using (var service = new MockClientService(initializer))
{
var request = new TestClientServiceRequest(service, "GET", null);
AutoResetEvent resetEvent = new AutoResetEvent(false);
var task = request.ExecuteAsync();
var error = string.Empty;
task.ContinueWith(t =>
{
// should not ENTER this code, the task should fail
resetEvent.Set();
}, TaskContinuationOptions.OnlyOnRanToCompletion);
task.ContinueWith(t =>
{
// catch the error
error = t.Exception.InnerException.ToString();
resetEvent.Set();
}, TaskContinuationOptions.NotOnRanToCompletion);
resetEvent.WaitOne();
Assert.True(error.Contains(handler.ExpectedError), "Error message is invalid");
Assert.That(handler.Calls, Is.EqualTo(1));
}
}
public void ExecuteAsync_NoCallback_Test()
{
var handler = new BatchMessageHandler(true);
var initializer = new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
};
using (var service = new MockClientService(initializer, "http://sample.com"))
{
var responses = new List <Tuple <MockResponse, RequestError, HttpResponseMessage> >();
var batch = new BatchRequest(service);
var request1 = new TestClientServiceRequest(service, new MockRequest
{
ETag = "\"100\"",
Name = "Name1"
});
var request2 = new TestClientServiceRequest(service, new MockRequest
{
ETag = "\"200\"",
Name = "Name1-1"
});
batch.Queue <MockResponse>(request1, null);
batch.Queue <MockResponse>(request2, null);
batch.ExecuteAsync().Wait();
}
}
/// <summary> Helper test to test canceling media upload in the middle.</summary>
/// <param name="cancelRequest">The request index to cancel.</param>
private void TestChunkUploadFail_Cancel(int cancelRequest)
{
int chunkSize = 100;
var payload = Encoding.UTF8.GetBytes(UploadTestData);
var handler = new MultipleChunksMessageHandler(true, ServerError.None, payload.Length, chunkSize, false);
handler.CancellationTokenSource = new CancellationTokenSource();
handler.CancelRequestNum = cancelRequest;
using (var service = new MockClientService(new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
}))
{
var stream = new MemoryStream(payload);
var upload = new MockResumableUpload(service, stream, "text/plain");
upload.ChunkSize = chunkSize;
try
{
var result = upload.UploadAsync(handler.CancellationTokenSource.Token).Result;
Assert.Fail();
}
catch (AggregateException ae)
{
Assert.IsInstanceOf <TaskCanceledException>(ae.InnerException);
}
Assert.That(handler.Calls, Is.EqualTo(cancelRequest));
}
}
public void TestUploadProgress()
{
int chunkSize = 200;
var payload = Encoding.UTF8.GetBytes(UploadTestData);
var handler = new MultipleChunksMessageHandler(true, ServerError.None, payload.Length, chunkSize);
using (var service = new MockClientService(new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
}))
{
var stream = new MemoryStream(payload);
var upload = new MockResumableUpload(service, stream, "text/plain");
upload.ChunkSize = chunkSize;
var progressEvents = new List <IUploadProgress>();
upload.ProgressChanged += (progress) =>
{
progressEvents.Add(progress);
};
upload.Upload();
// Starting (1) + Uploading (2) + Completed (1)
Assert.That(progressEvents.Count, Is.EqualTo(4));
Assert.That(progressEvents[0].Status, Is.EqualTo(UploadStatus.Starting));
Assert.That(progressEvents[1].Status, Is.EqualTo(UploadStatus.Uploading));
Assert.That(progressEvents[2].Status, Is.EqualTo(UploadStatus.Uploading));
Assert.That(progressEvents[3].Status, Is.EqualTo(UploadStatus.Completed));
}
}
public async Task TestUploadCancelled(
[CombinatorialValues(true, false)] bool knownSize,
[CombinatorialValues(1, 2, 3, 4, 5)] int cancelOnCall)
{
int chunkSize = 100;
using (var server = new MultiChunkCancellableServer(_server, cancelOnCall))
using (var service = new MockClientService(server.HttpPrefix))
{
var content = knownSize ? new MemoryStream(uploadTestBytes) : new UnknownSizeMemoryStream(uploadTestBytes);
var uploader = new TestResumableUpload(service, "MultiChunk", "POST", content, "text/plain", chunkSize);
if (cancelOnCall == 1)
{
var progress = uploader.UploadAsync(server.CancellationToken).Result;
Assert.Equal(UploadStatus.Failed, progress.Status);
Assert.IsAssignableFrom <OperationCanceledException>(progress.Exception);
}
else
{
await Assert.ThrowsAsync <TaskCanceledException>(
() => uploader.UploadAsync(server.CancellationToken));
}
Assert.Equal(cancelOnCall, server.Requests.Count);
}
}
public void TestUploadInBadServer_NotFound_JsonError(
[CombinatorialValues(true, false)] bool knownSize,
[CombinatorialValues(new[] { 0 }, new[] { 100 }, new[] { 410 })] int[] dodgyBytes)
{
string jsonError =
@"{ ""error"": {
""errors"": [
{
""domain"": ""global"",
""reason"": ""required"",
""message"": ""Login Required"",
""locationType"": ""header"",
""location"": ""Authorization""
}
],
""code"": 401,
""message"": ""Login Required""
}}";
using (var server = new MultiChunkBadServer(_server, dodgyBytes, HttpStatusCode.NotFound, jsonError))
using (var service = new MockClientService(server.HttpPrefix))
{
var content = knownSize ? new MemoryStream(uploadTestBytes) : new UnknownSizeMemoryStream(uploadTestBytes);
var uploader = new TestResumableUpload(service, "MultiChunk", "POST", content, "text/plain", 100);
IUploadProgress lastProgress = null;
uploader.ProgressChanged += p => lastProgress = p;
uploader.Upload();
Assert.NotNull(lastProgress);
Assert.Equal(UploadStatus.Failed, lastProgress.Status);
var exception = (GoogleApiException)lastProgress.Exception;
Assert.Contains("Message[Login Required] Location[Authorization - header] Reason[required] Domain[global]", exception.Message);
Assert.Equal("Login Required", exception.Error.Message);
}
}
public void TestUploadInBadServer_UploaderRestart(
[CombinatorialValues(new[] { 0 }, new[] { 100 }, new[] { 410 }, new[] { 0, 410 })] int[] dodgyBytes,
[CombinatorialValues(100, 400, 1000)] int chunkSize)
{
using (var server = new MultiChunkBadServer(_server, dodgyBytes, HttpStatusCode.NotFound))
using (var service = new MockClientService(server.HttpPrefix))
{
var content = new MemoryStream(uploadTestBytes);
Uri uploadUri = null;
IUploadProgress progress;
{
var uploader = new TestResumableUpload(service, "MultiChunk", "POST", content, "text/plain", chunkSize);
uploader.UploadSessionData += s => uploadUri = s.UploadUri;
progress = uploader.Upload();
}
Assert.NotNull(uploadUri);
int sanity = 0;
while (progress.Status == UploadStatus.Failed && sanity++ < 10)
{
var uploader = new TestResumableUpload(service, "MultiChunk", "POST", content, "text/plain", chunkSize);
progress = uploader.Resume(uploadUri);
}
Assert.Equal(UploadStatus.Completed, progress.Status);
Assert.Equal(uploadTestBytes, server.Bytes);
}
}
public void Execute_UnicodeCharacters()
{
var handler = new TestBodyMessageHnalder()
{
GZipEnabled = false,
ResponseObject = new MockResponse {
Id = 100, Name = @"مرحبا العالم"
},
ExpectedRequestObject = new MockRequest {
Name = @"مرحبا العالم! 您好，世界！"
}
};
var initializer = new BaseClientService.Initializer()
{
GZipEnabled = false,
HttpClientFactory = new MockHttpClientFactory(handler)
};
using (var service = new MockClientService(initializer))
{
handler.Serializer = service.Serializer;
var request = new TestClientServiceRequest(service, "GET", handler.ExpectedRequestObject);
var response = request.Execute();
Assert.That(handler.Calls, Is.EqualTo(1));
// the returned response should contain ETag, check that the service add the right ETag property on
// the response
handler.ResponseObject.ETag = handler.ResponseETag;
Assert.That(response, Is.EqualTo(handler.ResponseObject));
}
}
public void TestUploadInBadServer_NeedsResume(
[CombinatorialValues(true, false)] bool knownSize,
[CombinatorialValues(new[] { 0 }, new[] { 100 }, new[] { 410 }, new[] { 0, 410 })] int[] dodgyBytes,
[CombinatorialValues(100, 400, 1000)] int chunkSize,
[CombinatorialValues(4096, 51, 100)] int bufferSize)
{
var expectedCallCount = 1 + (uploadLength + chunkSize - 1) / chunkSize
+ dodgyBytes.Length * 2;
using (var server = new MultiChunkBadServer(_server, dodgyBytes, HttpStatusCode.NotFound))
using (var service = new MockClientService(server.HttpPrefix))
{
var content = knownSize ? new MemoryStream(uploadTestBytes) : new UnknownSizeMemoryStream(uploadTestBytes);
var uploader = new TestResumableUpload(service, "MultiChunk", "POST", content, "text/plain", chunkSize);
uploader.BufferSize = bufferSize;
var progress = uploader.Upload();
int sanity = 0;
while (progress.Status == UploadStatus.Failed && sanity++ < 10)
{
progress = uploader.Resume();
}
Assert.Equal(UploadStatus.Completed, progress.Status);
Assert.Equal(expectedCallCount, server.Requests.Count);
Assert.Equal(uploadTestBytes, server.Bytes);
}
}
/// <summary>
/// A subtest for testing execute when an exception is thrown during sending the request, with or without
/// back-off. If back-off handler is attached to the service's message handler, there are going to be several
/// retries (up to 2 minutes).
/// </summary>
/// <param name="backOff">Indicates if back-off handler is attached to the service.</param>
private void SubtestExecute_ThrowException(bool backOff)
{
var handler = new MockMessageHandler(true);
var initializer = new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
};
// by default back-off is used, so disable it in case backOff is false
if (!backOff)
{
initializer.DefaultExponentialBackOffPolicy = BaseClientService.ExponentialBackOffPolicy.None;
}
using (var service = new MockClientService(initializer))
{
var request = new TestClientServiceRequest(service, "GET", null);
Assert.Throws <InvalidOperationMockException>(() => request.Execute());
// if back-off is enabled, we use 2 minutes maximum wait time for a request, so we should make lg(120)
// + 1 calls
int calls = backOff ? (int)Math.Ceiling(Math.Log(120, 2) + 1) : 1;
Assert.That(handler.Calls, Is.EqualTo(calls));
}
}
/// <summary>
/// A subtest for testing async execute when an exception is thrown during sending the request, with or without
/// back-off handler. If back-off handler is attached to the service's message handler, there are going to be
/// several retries (up to 2 minutes).
/// </summary>
/// <param name="backOff">Indicates if back-off handler is attached to the service.</param>
private void SubtestExecuteAsync_ThrowException(bool backOff)
{
var handler = new MockMessageHandler(true);
var initializer = new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(handler)
};
// by default back-off is used, so disable it in case backOff is false
if (!backOff)
{
initializer.DefaultExponentialBackOffPolicy = BaseClientService.ExponentialBackOffPolicy.None;
}
using (var service = new MockClientService(initializer))
{
var request = new TestClientServiceRequest(service, "GET", null);
var task = request.ExecuteAsync();
try
{
var result = task.Result;
Assert.Fail("Exception should be thrown");
}
catch (AggregateException ex)
{
Assert.That(ex.InnerException, Is.AssignableFrom(typeof(InvalidOperationMockException)));
}
// if back-off is enabled, we use 2 minutes maximum wait time for a request, so we should make lg(120)
// + 1 calls
int calls = backOff ? (int)Math.Ceiling(Math.Log(120, 2) + 1) : 1;
Assert.That(handler.Calls, Is.EqualTo(calls));
}
}
public void TestGetWithUrlTooLongByDefault()
{
// Build a query string such that the whole URI adds up to 2049 characters
var query = "q=" + new String('x', 1020) + "&x=" + new String('y', 1000);
var uri = "http://www.example.com/";
var requestUri = uri + "?" + query;
var request = new HttpRequestMessage(HttpMethod.Get, requestUri);
var messageHandler = new MockMessageHandler();
using (var service = new MockClientService(new BaseClientService.Initializer()
{
HttpClientFactory = new MockHttpClientFactory(messageHandler)
}))
{
service.HttpClient.SendAsync(request);
// Confirm the test URI is one character too long.
Assert.Equal(DefaultMaxUrlLength + 1, (uint)requestUri.Length);
// Confirm the request was modified correctly:
Assert.Equal(HttpMethod.Post, request.Method);
Assert.Equal("GET", request.Headers.GetValues("X-HTTP-Method-Override").Single());
Assert.Equal(new MediaTypeHeaderValue("application/x-www-form-urlencoded"), request.Content.Headers.ContentType);
Assert.Equal(new Uri(uri), request.RequestUri);
Assert.Equal(query, messageHandler.RequestContent);
}
}
public void Download_Error_PlaintextResponse()
{
using (var service = new MockClientService())
{
var downloader = new MediaDownloader(service);
IList <IDownloadProgress> progressList = new List <IDownloadProgress>();
downloader.ProgressChanged += (p) =>
{
progressList.Add(p);
};
var outputStream = new MemoryStream();
downloader.Download(_httpPrefix + "NotFoundPlainText", outputStream);
var lastProgress = progressList.LastOrDefault();
Assert.Equal(DownloadStatus.Failed, lastProgress.Status);
GoogleApiException exception = Assert.IsType <GoogleApiException>(lastProgress.Exception);
Assert.Equal(HttpStatusCode.NotFound, exception.HttpStatusCode);
Assert.Equal("The service TestService has thrown an exception. HttpStatusCode is NotFound. No error message was specified.", exception.Message);
Assert.Contains(
$"The service TestService has thrown an exception.{Environment.NewLine}" +
$"HttpStatusCode is NotFound.{Environment.NewLine}" +
$"No JSON error details were specified.{Environment.NewLine}" +
$"Raw error details are: {NotFoundError}", exception.ToString());
Assert.True(exception.Error.IsOnlyRawContent);
}
}
private void SubtestCreateRequest_SupportedMethod(string method)
{
using (var service = new MockClientService("https://build_request_params"))
{
var request = new TestClientServiceRequest(service, method, null);
var httpRequest = request.CreateRequest();
}
}
public void CreateRequest_UnsupportedMethods()
{
using (var service = new MockClientService("https://build_request_params"))
{
var request = new TestClientServiceRequest(service, "Unsupported", null);
Assert.Throws <ArgumentOutOfRangeException>(() => request.CreateRequest());
}
}
private IClientService CreateClientService(DiscoveryVersion version)
{
var client = new MockClientService();
if (version == DiscoveryVersion.Version_0_3)
{
client.SetFeatures(new[] { Features.LegacyDataResponse.GetStringValue() });
}
return(client);
}
/// <summary>Creates a client service for the given features.</summary>
private IClientService CreateClientService(Features?features = null)
{
var client = new MockClientService();
if (features.HasValue)
{
client.SetFeatures(new[] { Utilities.GetEnumStringValue(features.Value) });
}
return(client);
}
public void CreateRequest_ETag()
{
var body = new MockRequest {
Name = "long long name"
};
using (var service = new MockClientService())
{
// no ETag (ETag = null)
var request = new TestClientServiceRequest(service, HttpConsts.Get, body);
var httpRequest = request.CreateRequest();
Assert.That(httpRequest.Headers.IfMatch.Count, Is.EqualTo(0));
Assert.That(httpRequest.Headers.IfNoneMatch.Count, Is.EqualTo(0));
// ETag has a value, but ETag action is ignored
body.ETag = "\"ETAG_HERE\"";
request = new TestClientServiceRequest(service, HttpConsts.Get, body);
request.ETagAction = ETagAction.Ignore;
httpRequest = request.CreateRequest();
Assert.That(httpRequest.Headers.IfMatch.Count, Is.EqualTo(0));
Assert.That(httpRequest.Headers.IfNoneMatch.Count, Is.EqualTo(0));
// ETag has a value, so use default action (Get -> If-None-Match)
request = new TestClientServiceRequest(service, HttpConsts.Get, body);
httpRequest = request.CreateRequest();
Assert.That(httpRequest.Headers.IfMatch.Count, Is.EqualTo(0));
Assert.That(httpRequest.Headers.IfNoneMatch.Count, Is.EqualTo(1));
Assert.That(httpRequest.Headers.IfNoneMatch.First(), Is.EqualTo(new EntityTagHeaderValue(body.ETag)));
// ETag has a value, so use default action (Post -> If-Match)
request = new TestClientServiceRequest(service, HttpConsts.Post, body);
httpRequest = request.CreateRequest();
Assert.That(httpRequest.Headers.IfNoneMatch.Count, Is.EqualTo(0));
Assert.That(httpRequest.Headers.IfMatch.Count, Is.EqualTo(1));
Assert.That(httpRequest.Headers.IfMatch.First(), Is.EqualTo(new EntityTagHeaderValue(body.ETag)));
// ETag has a value, default is override, use the specified ETag action
request = new TestClientServiceRequest(service, HttpConsts.Post, body);
request.ETagAction = ETagAction.IfNoneMatch;
httpRequest = request.CreateRequest();
Assert.That(httpRequest.Headers.IfMatch.Count, Is.EqualTo(0));
Assert.That(httpRequest.Headers.IfNoneMatch.Count, Is.EqualTo(1));
Assert.That(httpRequest.Headers.IfNoneMatch.First(), Is.EqualTo(new EntityTagHeaderValue(body.ETag)));
// ETag has a value, default is override, use the specified ETag action
request = new TestClientServiceRequest(service, HttpConsts.Get, body);
request.ETagAction = ETagAction.IfMatch;
httpRequest = request.CreateRequest();
Assert.That(httpRequest.Headers.IfNoneMatch.Count, Is.EqualTo(0));
Assert.That(httpRequest.Headers.IfMatch.Count, Is.EqualTo(1));
Assert.That(httpRequest.Headers.IfMatch.First(), Is.EqualTo(new EntityTagHeaderValue(body.ETag)));
}
}
public void TestUploadWithUploaderRestart_UnknownSize()
{
// Unknown stream size not supported, exception always thrown
using (var server = new MultiChunkServer(_server))
using (var service = new MockClientService(server.HttpPrefix))
{
var content = new UnknownSizeMemoryStream(uploadTestBytes);
var uploader = new TestResumableUpload(service, "whatever", "PUT", content, "", 100);
var url = new Uri("http://what.ever/");
Assert.ThrowsAsync <NotImplementedException>(async() => await uploader.ResumeAsync(url));
}
}
/// <summary>
/// Uses MediaDownloader to download the contents of a URI.
/// Asserts that the download succeeded and returns the resulting content as a string.
/// </summary>
/// <param name="uri">Uri to download</param>
/// <returns></returns>
private string SimpleDownload(string uri)
{
using (var service = new MockClientService())
{
var downloader = new MediaDownloader(service);
var outputStream = new MemoryStream();
var result = downloader.Download(uri, outputStream);
Assert.AreEqual(result.Status, DownloadStatus.Completed);
Assert.IsNull(result.Exception);
Assert.AreEqual(result.BytesDownloaded, outputStream.Position);
return Encoding.UTF8.GetString(outputStream.GetBuffer(), 0, (int)outputStream.Position);
}
}
public void Download_Error_JsonResponse()
{
using (var service = new MockClientService())
{
var downloader = new MediaDownloader(service);
IList<IDownloadProgress> progressList = new List<IDownloadProgress>();
downloader.ProgressChanged += (p) =>
{
progressList.Add(p);
};
var outputStream = new MemoryStream();
downloader.Download(_httpPrefix + "BadRequestJson", outputStream);
var lastProgress = progressList.LastOrDefault();
Assert.That(lastProgress.Status, Is.EqualTo(DownloadStatus.Failed));
GoogleApiException exception = (GoogleApiException) lastProgress.Exception;
Assert.That(exception.HttpStatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
// Just a smattering of checks - if these two pass, it's surely okay.
Assert.That(exception.Error.Code, Is.EqualTo(BadRequestError.Code));
Assert.That(exception.Error.Errors[0].Message, Is.EqualTo(BadRequestError.Errors[0].Message));
}
}
public void Download_Error_PlaintextResponse()
{
using (var service = new MockClientService())
{
var downloader = new MediaDownloader(service);
IList<IDownloadProgress> progressList = new List<IDownloadProgress>();
downloader.ProgressChanged += (p) =>
{
progressList.Add(p);
};
var outputStream = new MemoryStream();
downloader.Download(_httpPrefix + "NotFoundPlainText", outputStream);
var lastProgress = progressList.LastOrDefault();
Assert.That(lastProgress.Status, Is.EqualTo(DownloadStatus.Failed));
GoogleApiException exception = (GoogleApiException) lastProgress.Exception;
Assert.That(exception.HttpStatusCode, Is.EqualTo(HttpStatusCode.NotFound));
Assert.That(exception.Message, Is.EqualTo(NotFoundError));
Assert.IsNull(exception.Error);
}
}
public void Download_NoContent()
{
using (var service = new MockClientService())
{
var downloader = new MediaDownloader(service);
IList<IDownloadProgress> progressList = new List<IDownloadProgress>();
downloader.ProgressChanged += (p) =>
{
progressList.Add(p);
};
var outputStream = new MemoryStream();
downloader.Download(_httpPrefix + "NoContent", outputStream);
// We expect only one event -- "completed".
Assert.That(progressList.Count, Is.EqualTo(1));
var progress = progressList[0];
Assert.That(progress.Status, Is.EqualTo(DownloadStatus.Completed));
Assert.That(progress.BytesDownloaded, Is.EqualTo(0));
Assert.That(outputStream.Length, Is.EqualTo(0));
}
}
/// <summary>A helper test to test sync and async downloads.</summary>
/// <param name="chunkSize">The chunk size for each part.</param>
/// <param name="sync">Indicates if this download should be synchronously or asynchronously.</param>
/// <param name="cancelChunk">Defines the chunk at which to cancel the download request.</param>
/// <param name="target">Last component of the Uri to download</param>
private void Subtest_Download_Chunks(int chunkSize, bool sync = true, int cancelChunk = 0, string target = "content")
{
string downloadUri = _httpPrefix + target;
var cts = new CancellationTokenSource();
using (var service = new MockClientService())
{
var downloader = new MediaDownloader(service);
downloader.ChunkSize = chunkSize;
IList<IDownloadProgress> progressList = new List<IDownloadProgress>();
int progressUpdates = 0;
long lastBytesDownloaded = 0;
downloader.ProgressChanged += (p) =>
{
if (p.Status != DownloadStatus.Failed)
{
// We shouldn't receive duplicate notifications for the same range.
Assert.That(p.BytesDownloaded, Is.GreaterThan(lastBytesDownloaded));
}
lastBytesDownloaded = p.BytesDownloaded;
progressList.Add(p);
if (++progressUpdates == cancelChunk)
{
cts.Cancel();
}
};
var outputStream = new MemoryStream();
if (sync)
{
downloader.Download(downloadUri, outputStream);
}
else
{
try
{
var result = downloader.DownloadAsync(downloadUri, outputStream, cts.Token).Result;
if (result.Exception == null)
{
Assert.AreEqual(0, cancelChunk);
}
else
{
Assert.IsInstanceOf<OperationCanceledException>(result.Exception);
}
}
catch (AggregateException ex)
{
Assert.IsInstanceOf<TaskCanceledException>(ex.InnerException);
}
}
var lastProgress = progressList.LastOrDefault();
if (cancelChunk > 0)
{
// last request should fail
Assert.NotNull(lastProgress);
Assert.NotNull(lastProgress.Exception);
Assert.That(lastProgress.Status, Is.EqualTo(DownloadStatus.Failed));
Assert.That(lastProgress.BytesDownloaded, Is.EqualTo(chunkSize * cancelChunk));
}
else
{
Assert.NotNull(lastProgress);
Assert.Null(lastProgress.Exception);
Assert.That(lastProgress.Status, Is.EqualTo(DownloadStatus.Completed));
Assert.That(lastProgress.BytesDownloaded, Is.EqualTo(MediaContent.Length));
byte[] actual = outputStream.ToArray();
CollectionAssert.AreEqual(MediaContent, actual);
}
}
}
