private static async Task <T> ThrowsException <T>(ITestServer server) where T : Exception
{
return(await server.ExecuteAsync(async address =>
{
// Arrange
var retryHandler = new HttpRetryHandler();
var countingHandler = new CountingHandler {
InnerHandler = new HttpClientHandler()
};
var httpClient = new HttpClient(countingHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, address))
{
MaxTries = 2,
RetryDelay = TimeSpan.Zero
};
// Act
Func <Task> actionAsync = () => retryHandler.SendAsync(
request,
new TestLogger(),
CancellationToken.None);
// Act & Assert
var exception = await Assert.ThrowsAsync <T>(actionAsync);
Assert.Equal(2, countingHandler.Hits);
return exception;
}));
}
private static async Task <T> ThrowsException <T>(ITestServer server) where T : Exception
{
return(await server.ExecuteAsync(async address =>
{
int maxTries = 2;
TimeSpan retryDelay = TimeSpan.Zero;
TestEnvironmentVariableReader testEnvironmentVariableReader = new TestEnvironmentVariableReader(
new Dictionary <string, string>()
{
[EnhancedHttpRetryHelper.RetryCountEnvironmentVariableName] = maxTries.ToString(),
[EnhancedHttpRetryHelper.DelayInMillisecondsEnvironmentVariableName] = retryDelay.TotalMilliseconds.ToString()
});
// Arrange
var retryHandler = new HttpRetryHandler(testEnvironmentVariableReader);
var countingHandler = new CountingHandler {
InnerHandler = new HttpClientHandler()
};
var httpClient = new HttpClient(countingHandler);
var request = new HttpRetryHandlerRequest(httpClient, () => new HttpRequestMessage(HttpMethod.Get, address))
{
MaxTries = maxTries,
RetryDelay = retryDelay
};
// Act
Func <Task> actionAsync = () => retryHandler.SendAsync(
request,
new TestLogger(),
CancellationToken.None);
// Act & Assert
var exception = await Assert.ThrowsAsync <T>(actionAsync);
Assert.Equal(2, countingHandler.Hits);
return exception;
}));
}
private async Task BasicOfflineTest()
{
await ClearStore();
DateTime now = DateTime.UtcNow;
int seed = now.Year * 10000 + now.Month * 100 + now.Day;
Log("Using random seed: {0}", seed);
Random rndGen = new Random(seed);
CountingHandler handler = new CountingHandler();
var requestsSentToServer = 0;
var offlineReadyClient = CreateClient(handler);
var localStore = new MobileServiceSQLiteStore(StoreFileName);
Log("Defined the table on the local store");
localStore.DefineTable <OfflineReadyItem>();
await offlineReadyClient.SyncContext.InitializeAsync(localStore);
Log("Initialized the store and sync context");
var localTable = offlineReadyClient.GetSyncTable <OfflineReadyItem>();
var remoteTable = offlineReadyClient.GetTable <OfflineReadyItem>();
var item = new OfflineReadyItem(rndGen);
try
{
await localTable.InsertAsync(item);
Log("Inserted the item to the local store:", item);
Log("Validating that the item is not in the server table");
try
{
requestsSentToServer++;
await remoteTable.LookupAsync(item.Id);
Assert.Fail("Error, item is present in the server");
}
catch (MobileServiceInvalidOperationException ex)
{
Log("Ok, item is not in the server: {0}", ex.Message);
}
Func <int, bool> validateRequestCount = expectedCount =>
{
Log("So far {0} requests sent to the server", handler.RequestCount);
if (handler.RequestCount != expectedCount)
{
Log("Error, expected {0} requests to have been sent to the server", expectedCount);
return(false);
}
else
{
return(true);
}
};
if (!validateRequestCount(requestsSentToServer))
{
Assert.Fail(string.Format("Error, expected {0} requests to have been sent to the server", requestsSentToServer));
}
Log("Pushing changes to the server");
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer++;
if (!validateRequestCount(requestsSentToServer))
{
Assert.Fail(string.Format("Error, expected {0} requests to have been sent to the server", requestsSentToServer));
}
Log("Push done; now verifying that item is in the server");
var serverItem = await remoteTable.LookupAsync(item.Id);
requestsSentToServer++;
Log("Retrieved item from server: {0}", serverItem);
if (serverItem.Equals(item))
{
Log("Items are the same");
}
else
{
Assert.Fail(string.Format("Items are different. Local: {0}; remote: {1}", item, serverItem));
}
Log("Now updating the item locally");
item.Flag = !item.Flag;
item.Age++;
item.Date = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond, DateTimeKind.Utc);
await localTable.UpdateAsync(item);
Log("Item has been updated");
var newItem = new OfflineReadyItem(rndGen);
Log("Adding a new item to the local table: {0}", newItem);
await localTable.InsertAsync(newItem);
if (!validateRequestCount(requestsSentToServer))
{
Assert.Fail(string.Format("Error, expected {0} requests to have been sent to the server", requestsSentToServer));
}
Log("Pushing the new changes to the server");
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer += 2;
if (!validateRequestCount(requestsSentToServer))
{
Assert.Fail(string.Format("Error, expected {0} requests to have been sent to the server", requestsSentToServer));
}
Log("Push done. Verifying changes on the server");
serverItem = await remoteTable.LookupAsync(item.Id);
requestsSentToServer++;
if (serverItem.Equals(item))
{
Log("Updated items are the same");
}
else
{
Assert.Fail(string.Format("Items are different. Local: {0}; remote: {1}", item, serverItem));
}
serverItem = await remoteTable.LookupAsync(newItem.Id);
requestsSentToServer++;
if (serverItem.Equals(newItem))
{
Log("New inserted item is the same");
}
else
{
Assert.Fail(string.Format("Items are different. Local: {0}; remote: {1}", item, serverItem));
}
Log("Cleaning up");
await localTable.DeleteAsync(item);
await localTable.DeleteAsync(newItem);
Log("Local table cleaned up. Now sync'ing once more");
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer += 2;
if (!validateRequestCount(requestsSentToServer))
{
Assert.Fail(string.Format("Error, expected {0} requests to have been sent to the server", requestsSentToServer));
}
Log("Done");
}
catch (MobileServicePushFailedException ex)
{
Log("Push Result status from MobileServicePushFailedException: " + ex.PushResult.Status);
throw;
}
finally
{
localStore.Dispose();
ClearStore().Wait();
}
}
private static ZumoTest CreateBasicTest()
{
return(new ZumoTest("Basic offline scenario", async delegate(ZumoTest test)
{
DateTime now = DateTime.UtcNow;
int seed = now.Year * 10000 + now.Month * 100 + now.Day;
test.AddLog("Using random seed: {0}", seed);
Random rndGen = new Random(seed);
CountingHandler handler = new CountingHandler();
var requestsSentToServer = 0;
var offlineReadyClient = CreateClient(handler);
var localStore = new MobileServiceSQLiteStore(StoreFileName);
test.AddLog("Defined the table on the local store");
localStore.DefineTable <OfflineReadyItem>();
await offlineReadyClient.SyncContext.InitializeAsync(localStore);
test.AddLog("Initialized the store and sync context");
var localTable = offlineReadyClient.GetSyncTable <OfflineReadyItem>();
var remoteTable = offlineReadyClient.GetTable <OfflineReadyItem>();
var item = new OfflineReadyItem(rndGen);
await localTable.InsertAsync(item);
test.AddLog("Inserted the item to the local store:", item);
test.AddLog("Validating that the item is not in the server table");
try
{
requestsSentToServer++;
await remoteTable.LookupAsync(item.Id);
test.AddLog("Error, item is present in the server");
return false;
}
catch (MobileServiceInvalidOperationException ex)
{
test.AddLog("Ok, item is not in the server: {0}", ex.Message);
}
Func <int, bool> validateRequestCount = expectedCount =>
{
test.AddLog("So far {0} requests sent to the server", handler.RequestCount);
if (handler.RequestCount != expectedCount)
{
test.AddLog("Error, expected {0} requests to have been sent to the server", expectedCount);
return false;
}
else
{
return true;
}
};
if (!validateRequestCount(requestsSentToServer))
{
return false;
}
test.AddLog("Pushing changes to the server");
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer++;
if (!validateRequestCount(requestsSentToServer))
{
return false;
}
test.AddLog("Push done; now verifying that item is in the server");
var serverItem = await remoteTable.LookupAsync(item.Id);
requestsSentToServer++;
test.AddLog("Retrieved item from server: {0}", serverItem);
if (serverItem.Equals(item))
{
test.AddLog("Items are the same");
}
else
{
test.AddLog("Items are different. Local: {0}; remote: {1}", item, serverItem);
return false;
}
test.AddLog("Now updating the item locally");
item.Flag = !item.Flag;
item.Age++;
item.Date = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond, DateTimeKind.Utc);
await localTable.UpdateAsync(item);
test.AddLog("Item has been updated");
var newItem = new OfflineReadyItem(rndGen);
test.AddLog("Adding a new item to the local table: {0}", newItem);
await localTable.InsertAsync(newItem);
if (!validateRequestCount(requestsSentToServer))
{
return false;
}
test.AddLog("Pushing the new changes to the server");
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer += 2;
if (!validateRequestCount(requestsSentToServer))
{
return false;
}
test.AddLog("Push done. Verifying changes on the server");
serverItem = await remoteTable.LookupAsync(item.Id);
requestsSentToServer++;
if (serverItem.Equals(item))
{
test.AddLog("Updated items are the same");
}
else
{
test.AddLog("Items are different. Local: {0}; remote: {1}", item, serverItem);
return false;
}
serverItem = await remoteTable.LookupAsync(newItem.Id);
requestsSentToServer++;
if (serverItem.Equals(newItem))
{
test.AddLog("New inserted item is the same");
}
else
{
test.AddLog("Items are different. Local: {0}; remote: {1}", item, serverItem);
return false;
}
test.AddLog("Cleaning up");
await localTable.DeleteAsync(item);
await localTable.DeleteAsync(newItem);
test.AddLog("Local table cleaned up. Now sync'ing once more");
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer += 2;
if (!validateRequestCount(requestsSentToServer))
{
return false;
}
test.AddLog("Done");
return true;
}, ZumoTestGlobals.RuntimeFeatureNames.STRING_ID_TABLES));
}
public async Task BasicOfflineTest()
{
ClearStore();
DateTime now = DateTime.UtcNow;
int seed = now.Year * 10000 + now.Month * 100 + now.Day;
Random rndGen = new Random(seed);
CountingHandler handler = new CountingHandler();
var requestsSentToServer = 0;
var offlineReadyClient = CreateClient(handler);
var localStore = new MobileServiceSQLiteStore(StoreFileName);
localStore.DefineTable <OfflineReadyItem>();
await offlineReadyClient.SyncContext.InitializeAsync(localStore);
var localTable = offlineReadyClient.GetSyncTable <OfflineReadyItem>();
var remoteTable = offlineReadyClient.GetTable <OfflineReadyItem>();
var item = new OfflineReadyItem(rndGen);
try
{
await localTable.InsertAsync(item);
await Assert.ThrowsAsync <MobileServiceInvalidOperationException>(async() =>
{
requestsSentToServer++;
await remoteTable.LookupAsync(item.Id);
});
Func <int, bool> validateRequestCount = expectedCount => (handler.RequestCount == expectedCount);
Assert.True(validateRequestCount(requestsSentToServer));
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer++;
Assert.True(validateRequestCount(requestsSentToServer));
var serverItem = await remoteTable.LookupAsync(item.Id);
requestsSentToServer++;
Assert.Equal(serverItem, item);
item.Flag = !item.Flag;
item.Age++;
item.Date = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute, now.Second, now.Millisecond, DateTimeKind.Utc);
await localTable.UpdateAsync(item);
var newItem = new OfflineReadyItem(rndGen);
await localTable.InsertAsync(newItem);
Assert.True(validateRequestCount(requestsSentToServer));
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer += 2;
Assert.True(validateRequestCount(requestsSentToServer));
serverItem = await remoteTable.LookupAsync(item.Id);
requestsSentToServer++;
Assert.Equal(serverItem, item);
serverItem = await remoteTable.LookupAsync(newItem.Id);
requestsSentToServer++;
Assert.Equal(serverItem, newItem);
await localTable.DeleteAsync(item);
await localTable.DeleteAsync(newItem);
await offlineReadyClient.SyncContext.PushAsync();
requestsSentToServer += 2;
Assert.True(validateRequestCount(requestsSentToServer));
}
catch (MobileServicePushFailedException)
{
throw;
}
finally
{
localStore.Dispose();
ClearStore();
}
}
