/// <summary>
/// Test case: Produce a conflict and check that SyncConflict is triggered.
/// Also check that by returning false in SyncConflict, the Synchronize operation
/// is aborted and nothing else gets called.
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void ConflictTest()
{
string failureMessage = string.Empty;
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
using (Dataset d = syncManager.OpenOrCreateDataset("testDataset3"))
{
d.Put("testKey3", "the initial value");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
syncManager.WipeData(false);
using (Dataset d2 = syncManager.OpenOrCreateDataset("testDataset3"))
{
bool conflictTriggered = false;
d2.Put("testKey3", "a different value");
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
conflictTriggered = true;
return(false);
};
d2.OnSyncSuccess += delegate(object sender4, SyncSuccessEventArgs e4)
{
failureMessage += "Expecting OnSyncConflict instead of OnSyncSuccess\n";
};
d2.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
if (!conflictTriggered)
{
failureMessage += "Expecting OnSyncConflict instead of OnSyncFailure\n";
}
};
#if BCL35
d2.Synchronize();
#else
RunAsSync(async() => await d2.SynchronizeAsync());
#endif
}
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "Expecting OnSyncSuccess instead of OnSyncFailure\n";
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
}
}
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
public void ResolveConflictTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testDataset4");
Dataset d2 = null;
d.Put("a", "1");
d.Put("b", "2");
d.Put("c", "3");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
syncManager.WipeData(false);
d2 = syncManager.OpenOrCreateDataset("testDataset4");
d2.Put("a", "10");
d2.Put("b", "20");
d2.Put("c", "30");
bool resolved = false;
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
List <Amazon.CognitoSync.SyncManager.Record> resolvedRecords = new List <Amazon.CognitoSync.SyncManager.Record>();
int i = 0;
foreach (SyncConflict conflictRecord in conflicts)
{
if (i == 0)
{
resolvedRecords.Add(conflictRecord.ResolveWithLocalRecord());
}
else if (i == 1)
{
resolvedRecords.Add(conflictRecord.ResolveWithValue("42"));
}
else
{
resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
}
i++;
}
dataset.Resolve(resolvedRecords);
resolved = true;
return(true);
};
d2.OnSyncSuccess += delegate(object sender4, SyncSuccessEventArgs e4)
{
if (resolved)
{
if (d2.Get("a") != "10")
{
failureMessage += "Value for key 'a' should be '10'\n";
}
if (d2.Get("b") != "42")
{
failureMessage += "Value for key 'b' should be '42'\n";
}
if (d2.Get("c") != "3")
{
failureMessage += "Value for key 'c' should be '3'\n";
}
}
else
{
failureMessage += "Expecting SyncConflict instead of SyncSuccess\n";
}
ars.Set();
};
d2.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
failureMessage += "Expecting SyncConflict instead of SyncFailure\n";
ars.Set();
};
d2.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
};
d.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
failureMessage += "Expecting SyncConflict instead of SyncFailure\n";
ars.Set();
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
d.Dispose();
if (d2 != null)
{
d2.Dispose();
}
syncManager.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
public void ConflictTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Dataset d = syncManager.OpenOrCreateDataset("testDataset3");
Dataset d2 = null;
d.Put("testKey3", "the initial value");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
syncManager.WipeData(false);
d2 = syncManager.OpenOrCreateDataset("testDataset3");
bool conflictTriggered = false;
d2.Put("testKey3", "a different value");
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
conflictTriggered = true;
return(false);
};
d2.OnSyncSuccess += delegate(object sender4, SyncSuccessEventArgs e4)
{
failureMessage += "Expecting OnSyncConflict instead of OnSyncSuccess\n";
ars.Set();
};
d2.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
if (!conflictTriggered)
{
failureMessage += "Expecting OnSyncConflict instead of OnSyncFailure\n";
}
ars.Set();
};
d2.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
};
d.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
failureMessage += "Expecting OnSyncSuccess instead of OnSyncFailure\n";
ars.Set();
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
if (d2 != null)
{
d2.Dispose();
}
d.Dispose();
syncManager.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
public void DatasetCloudStorageTest()
{
AutoResetEvent ars = new AutoResetEvent(false);
string failureMessage = string.Empty;
CognitoSyncManager syncManager = null;
AutoResetEvent mainThreadArs = new AutoResetEvent(false);
Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() =>
{
syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint);
mainThreadArs.Set();
});
mainThreadArs.WaitOne();
syncManager.WipeData(false);
Thread.Sleep(2000);
Dataset d = syncManager.OpenOrCreateDataset("testDataset2");
d.Put("key", "he who must not be named");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
string erasedValue = d.Get("key");
syncManager.WipeData(false);
d.OnSyncSuccess += delegate(object sender2, SyncSuccessEventArgs e2)
{
string restoredValues = d.Get("key");
if (erasedValue == null)
{
failureMessage += "erasedValue should not be null\n";
}
if (restoredValues == null)
{
failureMessage += "restoredValues should not be null\n";
}
if (erasedValue != restoredValues)
{
failureMessage += "erasedValue should equal restoredValues\n";
}
ars.Set();
};
d.OnSyncFailure += delegate(object sender2, SyncFailureEventArgs e2)
{
failureMessage += "sync failed\n";
ars.Set();
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "sync failed\n";
ars.Set();
};
d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expected SyncSuccess instead of SyncConflict\n";
return(false);
};
d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) =>
{
failureMessage += "Did not expect DatasetMerged\n";
return(false);
};
d.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Did not expect DatasetDeleted\n";
return(false);
};
d.SynchronizeAsync(new AsyncOptions {
ExecuteCallbackOnMainThread = false
});
ars.WaitOne();
d.Dispose();
syncManager.Dispose();
Utils.AssertStringIsNullOrEmpty(failureMessage);
}
/// <summary>
/// Test case: Produce a conflict and check that the three ways provided by the SDK
/// for resolving a conflict (local wins, remote wins, and override) work. We also check
/// that returning true in SyncConflict allows the Synchronization operationn to continue.
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void ResolveConflictTest()
{
string failureMessage = string.Empty;
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
using (Dataset d = syncManager.OpenOrCreateDataset("testDataset4"))
{
d.Put("a", "1");
d.Put("b", "2");
d.Put("c", "3");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
syncManager.WipeData(false);
using (Dataset d2 = syncManager.OpenOrCreateDataset("testDataset4"))
{
d2.Put("a", "10");
d2.Put("b", "20");
d2.Put("c", "30");
bool resolved = false;
d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
List <Amazon.CognitoSync.SyncManager.Record> resolvedRecords = new List <Amazon.CognitoSync.SyncManager.Record>();
int i = 0;
foreach (SyncConflict conflictRecord in conflicts)
{
if (i == 0)
{
resolvedRecords.Add(conflictRecord.ResolveWithLocalRecord());
}
else if (i == 1)
{
resolvedRecords.Add(conflictRecord.ResolveWithValue("42"));
}
else
{
resolvedRecords.Add(conflictRecord.ResolveWithRemoteRecord());
}
i++;
}
dataset.Resolve(resolvedRecords);
resolved = true;
return(true);
};
d2.OnSyncSuccess += delegate(object sender4, SyncSuccessEventArgs e4)
{
if (resolved)
{
if (d2.Get("a") != "10")
{
failureMessage += "Value for key 'a' should be '10'\n";
}
if (d2.Get("b") != "42")
{
failureMessage += "Value for key 'b' should be '42'\n";
}
if (d2.Get("c") != "3")
{
failureMessage += "Value for key 'c' should be '3'\n";
}
}
else
{
failureMessage += "Expecting SyncConflict instead of SyncSuccess\n";
}
};
d2.OnSyncFailure += delegate(object sender4, SyncFailureEventArgs e4)
{
failureMessage += "Expecting SyncConflict instead of SyncFailure\n";
};
#if BCL35
d2.Synchronize();
#else
RunAsSync(async() => await d2.SynchronizeAsync());
#endif
}
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
}
}
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
// <summary>
/// Test case: Store a value in a dataset and sync it. Wipe all local data.
/// After synchronizing the dataset we should have our stored value back.
/// </summary>
//[TestMethod]
//[TestCategory("SyncManager")]
public void DatasetCloudStorageTest()
{
string failureMessage = string.Empty;
using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials))
{
syncManager.WipeData(false);
Thread.Sleep(2000);
using (Dataset d = syncManager.OpenOrCreateDataset("testDataset2"))
{
d.Put("key", "he who must not be named");
d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e)
{
d.ClearAllDelegates();
string erasedValue = d.Get("key");
syncManager.WipeData(false);
d.OnSyncSuccess += delegate(object sender2, SyncSuccessEventArgs e2)
{
string restoredValues = d.Get("key");
if (erasedValue == null)
{
failureMessage += "erasedValue should not be null\n";
}
if (restoredValues == null)
{
failureMessage += "restoredValues should not be null\n";
}
if (erasedValue != restoredValues)
{
failureMessage += "erasedValue should equal restoredValues\n";
}
};
d.OnSyncFailure += delegate(object sender2, SyncFailureEventArgs e2)
{
failureMessage += "sync failed\n";
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
};
d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e)
{
failureMessage += "sync failed\n";
};
d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts)
{
failureMessage += "Expected SyncSuccess instead of SyncConflict\n";
return(false);
};
d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) =>
{
failureMessage += "Did not expect DatasetMerged\n";
return(false);
};
d.OnDatasetDeleted += (Dataset dataset) =>
{
failureMessage += "Did not expect DatasetDeleted\n";
return(false);
};
#if BCL35
d.Synchronize();
#else
RunAsSync(async() => await d.SynchronizeAsync());
#endif
}
}
if (!string.IsNullOrEmpty(failureMessage))
{
Assert.Fail(failureMessage);
}
}
