/// <summary> /// Inits Cognito Sync with unauthenticated user credentials. /// </summary> public void InitWithoutFacebook() { enabled = true; // Enabling Logs //AmazonLogging.EnableSDKLogging = true; // CognitoAWSCredentials is recommended in the place of Developer credentials{accessKey,secretKey} for reasons of security best practices // CognitoAWSCredentials uses the CognitoIdentityProvider & provides temporary scoped AWS credentials from AssumeRoleWithWebIdentity // ref: http://mobile.awsblog.com/post/TxR1UCU80YEJJZ/Using-the-Amazon-Cognito-Credentials-Provider // Ref: http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#create-an-identity-pool // for setting up Cognito Identity Pools, can you use the sample code for .NET SDK try { credentials = new CachingCognitoAWSCredentials(); } catch (Exception ex) { Debug.LogException(ex); return; } // DefaultCognitoSyncManager is a high level CognitoSync Client which handles all Sync operations at a Dataset level. // Additionally, it also provides local storage of the Datasets which can be later Synchronized with the cloud(CognitoSync service) // This feature allows the user to continue working w/o internet access and sync with CognitoSync whenever possible syncManager = new DefaultCognitoSyncManager(credentials, new AmazonCognitoSyncConfig { RegionEndpoint = RegionEndpoint.USEast1 }); initializationPending = true; }
/* * Initialization. */ public static void Initialize(string poolId) { if (Initializing) { _log.Error("Already initializing"); return; } if (Initialized) { _log.Error("Already initialized"); return; } _log.Debug("Initializing"); Initializing = true; _poolId = poolId; _instance = new GameObject("BitszerAuctionHouse").AddComponent <AuctionHouse>(); UnityInitializer.AttachToGameObject(_instance.gameObject); AWSConfigs.HttpClient = AWSConfigs.HttpClientOption.UnityWebRequest; AWSConfigs.LoggingConfig.LogTo = LoggingOptions.None; _credentials = new CognitoAWSCredentials(_poolId, RegionEndpoint); _credentials.GetIdentityIdAsync(OnIdentityReceived); _syncManager = new CognitoSyncManager(_credentials, RegionEndpoint); }
private void Init(string authProvider, string accessToken) { enabled = true; if (string.IsNullOrEmpty(IDENTITY_POOL_ID)) { throw new NotSupportedException("Please setup your the identity pool id in SceneController"); } //Enable Logs AmazonLogging.Level = AmazonLogging.LoggingLevel.DEBUG; //Create a Credentials provider that uses Cognito Identity credentials = new CognitoAWSCredentials(IDENTITY_POOL_ID, ENDPOINT); //If fbAccesToken is set, we can use Cognito's authenticated identities if (accessToken != null) { credentials.AddLogin(authProvider, accessToken); } syncManager = new DefaultCognitoSyncManager(credentials, new AmazonCognitoSyncConfig { RegionEndpoint = ENDPOINT }); InitializeCharactersDataset(); }
/// <summary> /// Test case: Add and synchronize a dataset, then wipe data. Wiping data (while /// using unauthorized credentials) should wipe the dataset and the identity, /// so that the information in the dataset should no longer be retrievable. /// Check that the dataset is no longer in local memory and that syncing a /// dataset with the same record key does not cause a conflict. /// </summary> //[TestMethod] //[TestCategory("SyncManager")] public void WipeDataTest() { string failureMessage = string.Empty; CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials); syncManager.WipeData(false); Dataset d = syncManager.OpenOrCreateDataset("testDataset5"); d.Put("testKey", "testValue"); d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts) { failureMessage += "Expecting SyncSuccess instead of SyncConflict\n"; return(false); }; d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e) { failureMessage += "Expecting SyncSuccess instead of SyncFailure\n"; }; d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e) { syncManager.WipeData(); Dataset d2 = syncManager.OpenOrCreateDataset("testDataset5"); if (d2.Records.Count != 0) { failureMessage += "Expecting dataset to be empty due to local data wipe.\n"; } d2.Put("testKey", "newTestValue"); d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts) { failureMessage += "Expecting SyncSuccess instead of SyncConflict\n"; return(false); }; d2.OnSyncFailure += delegate(object sender2, SyncFailureEventArgs e2) { failureMessage += "Expecting SyncSuccess instead of SyncFailure\n"; }; d2.OnSyncSuccess += delegate(object sender2, SyncSuccessEventArgs e2) { if (d2.Get("testKey") != "newTestValue") { failureMessage += "Value for key 'testKey' should be 'newTestValue'\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); } }
public static void init() { String identityPoolId = "YOUR_IDENTITY_POOL_ID"; //Set your Identity Pool here Amazon.RegionEndpoint region = Amazon.RegionEndpoint.USEast1; if (String.IsNullOrEmpty(identityPoolId)) { throw new Exception("You need to set up an identity pool in CognitoSyncClientManager.cs"); } // CognitoAWSCredentials is recommended in the place of Developer credentials{accessKey,secretKey} for reasons of security best practices // CognitoAWSCredentials uses the CognitoIdentityProvider & provides temporary scoped AWS credentials from AssumeRoleWithWebIdentity // ref: http://mobile.awsblog.com/post/TxR1UCU80YEJJZ/Using-the-Amazon-Cognito-Credentials-Provider #if DEVELOPER_AUTHENTICATED_IDENTITIES // or to use developer authenticated identities CognitoAWSCredentials _credentials = new CognitoAWSCredentials(new ExampleIdentityProvider()); #else // Ref: http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#create-an-identity-pool // for setting up Cognito Identity Pools, can you use the sample code for .NET SDK _credentials = new CognitoAWSCredentials(identityPoolId, region); #endif // DefaultCognitoSyncManager is a high level CognitoSync Client which handles all Sync operations at a Dataset level. // Additionally, it also provides local storage of the Datasets which can be later Synchronized with the cloud(CognitoSync service) // This feature allows the user to continue working w/o internet access and sync with CognitoSync whenever possible _syncManager = new DefaultCognitoSyncManager(_credentials, new AmazonCognitoSyncConfig { RegionEndpoint = region }); }
private CognitoSyncViewModel() { credentials = new CognitoAWSCredentials(Constants.AWS_IDENTITY_POOL_ID, RegionEndpoint.EUWest1); syncManager = new CognitoSyncManager(credentials, new AmazonCognitoSyncConfig { RegionEndpoint = RegionEndpoint.EUWest1 }); datasets = new Dictionary <string, Dataset> (); }
/// <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 RemoveEntryTest() { 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("testRemoveDataset"); long originalCount = d.Metadata.RecordCount; d.Put("testKey", "testValue"); d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts) { failureMessage += "Expecting SyncSuccess instead of SyncConflict\n"; return(false); }; d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e) { failureMessage += "Expecting SyncSuccess instead of SyncFailure\n"; ars.Set(); }; d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e) { ars.Set(); }; d.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); Utils.AssertStringIsNullOrEmpty(failureMessage); d.Remove("testKey"); d.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); if (d.Metadata.RecordCount != originalCount) { failureMessage += "d.Metadata.RecordCount != originalCount\n"; } syncManager.Dispose(); d.Dispose(); Utils.AssertStringIsNullOrEmpty(failureMessage); }
void Start() { UnityInitializer.AttachToGameObject(this.gameObject); //Remove if you want to build on an IOS device. AWSConfigs.LoggingConfig.LogTo = LoggingOptions.UnityLogger; credentials = new CognitoAWSCredentials("" //Put your own identity pool id here. , RegionEndpoint.USEast1); syncManager = new CognitoSyncManager(credentials, RegionEndpoint.USEast1); playerInfo = syncManager.OpenOrCreateDataset("playerInfo"); playerInfo.OnSyncSuccess += SyncSuccessCallback; UpdateInformation(); }
// Start is called before the first frame update void Start() { UnityInitializer.AttachToGameObject(this.gameObject); AWSConfigs.HttpClient = AWSConfigs.HttpClientOption.UnityWebRequest; credentials = new CognitoAWSCredentials( "us-east-2:cd8a1e15-89bb-44b1-95b4-9225913c86b6", RegionEndpoint.USEast2 ); manager = new CognitoSyncManager(credentials, RegionEndpoint.USEast2); playerInfo = manager.OpenOrCreateDataset("playerInfo"); playerInfo.OnSyncSuccess += PlayerInfo_OnSyncSuccess; UpdateInformation(); }
//[TestMethod] //[TestCategory("SyncManager")] public void RemoveEntryTest() { string failureMessage = string.Empty; using (var syncManager = new CognitoSyncManager(UnAuthCredentials)) { syncManager.WipeData(false); Dataset d = syncManager.OpenOrCreateDataset("testRemoveDataset"); long originalCount = d.Metadata.RecordCount; d.Put("testKey", "testValue"); d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts) { failureMessage += "Expecting SyncSuccess instead of SyncConflict\n"; return(false); }; d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e) { failureMessage += "Expecting SyncSuccess instead of SyncFailure\n"; }; #if BCL35 d.Synchronize(); #else RunAsSync(async() => await d.SynchronizeAsync()); #endif if (!string.IsNullOrEmpty(failureMessage)) { Assert.Fail(failureMessage); } d.Remove("testKey"); #if BCL35 d.Synchronize(); #else RunAsSync(async() => await d.SynchronizeAsync()); #endif if (d.Metadata.RecordCount != originalCount) { failureMessage += "d.Metadata.RecordCount != originalCount\n"; } d.Dispose(); if (!string.IsNullOrEmpty(failureMessage)) { Assert.Fail(failureMessage); } } }
//[TestMethod] //[TestCategory("SyncManager")] public void DatasetLocalStorageTest() { { using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials)) { syncManager.WipeData(false); Dataset d = syncManager.OpenOrCreateDataset("testDataset"); d.Put("testKey", "testValue"); } } { using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials)) { Dataset d = syncManager.OpenOrCreateDataset("testDataset"); Assert.AreEqual("testValue", d.Get("testKey")); } } }
// Use this for initialization void Start() { // Enabling Logs // AmazonLogging.EnableSDKLogging = true; difficultyLevels = new string[] { "Expert", "Medium", "Easy" }; try { CognitoSyncClientManager.init(); syncManager = CognitoSyncClientManager.CognitoSyncManagerInstance; } catch (Exception ex) { statusMessage = "Please setup the Cognito credentials for the AWSPrefab in the scene"; Debug.LogException(ex); return; } // Loading the datasets playerInfo = syncManager.OpenOrCreateDataset("PlayerInfo"); playerSettings = syncManager.OpenOrCreateDataset("PlayerSettings"); // fetching locally stored data alias = string.IsNullOrEmpty(playerInfo.Get("alias")) ? "Enter ur alias" : playerInfo.Get("alias"); playerName = string.IsNullOrEmpty(playerInfo.Get("playerName")) ? "Enter ur fullName" : playerInfo.Get("playerName"); selectedDifficultyLevel = string.IsNullOrEmpty(playerSettings.Get("selectedDifficultyLevel")) ? 0 : int.Parse(playerSettings.Get("selectedDifficultyLevel")); statusMessage = "Welcome .."; // when ds.Synchronize() is called the localDataset is merged with the remoteDataset // OnDatasetDeleted, OnDatasetMerged, OnDatasetSuccess, the corresponding callback is fired. // The developer has the freedom of handling these events needed for the Dataset playerInfo.OnSyncSuccess += this.HandleSyncSuccess; // OnSyncSucess uses events/delegates pattern playerInfo.OnSyncFailure += this.HandleSyncFailure; // OnSyncFailure uses events/delegates pattern playerInfo.OnSyncConflict = this.HandleSyncConflict; playerInfo.OnDatasetMerged = this.HandleDatasetMerged; playerInfo.OnDatasetDeleted = this.HandleDatasetDeleted; // playerSettings Dataset shows the use of default callback for syncManager // The OnSyncConflict event defaults to last writer wins policy // OnSyncSucess, OnSyncFailure, OnDatasetMerged events are ignored // OnDatasetDeleted defaults to false }
public static void init() { // CognitoAWSCredentials is recommended in the place of Developer credentials{accessKey,secretKey} for reasons of security best practices // CognitoAWSCredentials uses the CognitoIdentityProvider & provides temporary scoped AWS credentials from AssumeRoleWithWebIdentity // ref: http://mobile.awsblog.com/post/TxR1UCU80YEJJZ/Using-the-Amazon-Cognito-Credentials-Provider #if DEVELOPER_AUTHENTICATED_IDENTITIES // or to use developer authenticated identities CachingCognitoAWSCredentials _credentials = new CachingCognitoAWSCredentials(AmazonInitializer.DefaultUnAuthRole, AmazonInitializer.DefaultAuthRole, new ExampleIdentityProvider(), new AmazonSecurityTokenServiceClient(AmazonInitializer.CognitoRegionEndpoint)); #else // Ref: http://docs.aws.amazon.com/mobile/sdkforandroid/developerguide/cognito-auth.html#create-an-identity-pool // for setting up Cognito Identity Pools, can you use the sample code for .NET SDK _credentials = new CachingCognitoAWSCredentials(); #endif // DefaultCognitoSyncManager is a high level CognitoSync Client which handles all Sync operations at a Dataset level. // Additionally, it also provides local storage of the Datasets which can be later Synchronized with the cloud(CognitoSync service) // This feature allows the user to continue working w/o internet access and sync with CognitoSync whenever possible _syncManager = new DefaultCognitoSyncManager(_credentials, new AmazonCognitoSyncConfig { RegionEndpoint = AmazonInitializer.CognitoRegionEndpoint }); }
// Start is called before the first frame update void Start() { Debug.Log("Login Client Started"); AWSConfigs.HttpClient = AWSConfigs.HttpClientOption.UnityWebRequest; awsCredentials = new CognitoAWSCredentials( "ap-south-1:0edf52b9-63a5-4fbe-9299-aa9c9413aa2d", // Identity pool ID RegionEndpoint.APSouth1 // Region ); syncManager = new CognitoSyncManager(awsCredentials, RegionEndpoint.APSouth1); dbClient = new AmazonDynamoDBClient(awsCredentials, RegionEndpoint.APSouth1); dbContext = new DynamoDBContext(dbClient); playerInfo = syncManager.OpenOrCreateDataset("playerInfo"); playerInfo.OnSyncSuccess += SyncSuccessCallBack; playerInfo.OnSyncFailure += HandleSyncFailure; fbandcsInitiated = fbandcsInitiated + 1; PlayGamesClientConfiguration config = new PlayGamesClientConfiguration.Builder().RequestEmail().RequestIdToken().RequestServerAuthCode(false).Build(); PlayGamesPlatform.InitializeInstance(config); PlayGamesPlatform.DebugLogEnabled = true; PlayGamesPlatform.Activate(); //Social.localUser.Authenticate(GoogleLoginCallback); }
public void DatasetLocalStorageTest() { { 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("testDataset"); d.Put("testKey", "testValue"); syncManager.Dispose(); } { CognitoSyncManager syncManager = null; AutoResetEvent mainThreadArs = new AutoResetEvent(false); Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() => { syncManager = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint); mainThreadArs.Set(); }); mainThreadArs.WaitOne(); try { Dataset d = syncManager.OpenOrCreateDataset("testDataset"); Utils.AssertTrue("testValue" == d.Get("testKey")); } finally { syncManager.Dispose(); } } }
public void MergeTest() { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); string uniqueName = ((DateTime.UtcNow - epoch).TotalSeconds).ToString(); string uniqueName2 = uniqueName + "_"; UnAuthCredentials.Clear(); AutoResetEvent ars = new AutoResetEvent(false); string failureMessage = string.Empty; CognitoSyncManager sm1 = null; AutoResetEvent mainThreadArs = new AutoResetEvent(false); Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() => { sm1 = new CognitoSyncManager(AuthCredentials, TestRunner.RegionEndpoint); mainThreadArs.Set(); }); mainThreadArs.WaitOne(); sm1.WipeData(false); Thread.Sleep(2000); Dataset d = sm1.OpenOrCreateDataset("test"); d.Put(uniqueName, uniqueName); d.OnSyncSuccess += delegate(object s1, SyncSuccessEventArgs e1) { ars.Set(); }; d.OnSyncFailure += delegate(object s, SyncFailureEventArgs e) { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); ars.Set(); }; d.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) => { failureMessage += "Not expecting OnDatasetMerged\n"; return(false); }; d.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); d.Dispose(); sm1.Dispose(); Utils.AssertStringIsNullOrEmpty(failureMessage); UnAuthCredentials.Clear(); CognitoSyncManager sm2 = null; Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() => { sm2 = new CognitoSyncManager(UnAuthCredentials, TestRunner.RegionEndpoint); mainThreadArs.Set(); }); mainThreadArs.WaitOne(); Thread.Sleep(2000); Dataset d2 = sm2.OpenOrCreateDataset("test"); d2.Put(uniqueName2, uniqueName2); d2.OnSyncSuccess += delegate(object s2, SyncSuccessEventArgs e2) { ars.Set(); }; d2.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); ars.Set(); }; d2.OnSyncConflict += (Dataset dataset, List <SyncConflict> conflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d2.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d2.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) => { failureMessage += "Not expecting OnDatasetMerged\n"; return(false); }; d2.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); d2.Dispose(); sm2.Dispose(); Utils.AssertStringIsNullOrEmpty(failureMessage); AuthCredentials.Clear(); UnAuthCredentials.Clear(); CognitoSyncManager sm3 = null; Amazon.Runtime.Internal.UnityRequestQueue.Instance.ExecuteOnMainThread(() => { sm3 = new CognitoSyncManager(AuthCredentials, TestRunner.RegionEndpoint); mainThreadArs.Set(); }); mainThreadArs.WaitOne(); Thread.Sleep(2000); Dataset d3 = sm3.OpenOrCreateDataset("test"); bool mergeTriggered = false; d3.OnSyncSuccess += (object sender, SyncSuccessEventArgs e) => { if (!mergeTriggered) { failureMessage += "Expecting DatasetMerged instead of OnSyncSuccess\n"; } ars.Set(); }; d3.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); ars.Set(); }; d3.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d3.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d3.OnDatasetMerged += delegate(Dataset ds, List <string> datasetNames) { mergeTriggered = true; return(true); }; d3.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); Utils.AssertStringIsNullOrEmpty(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); } }
/// <summary> /// Test Case: /// </summary> //[TestMethod] //[TestCategory("SyncManager")] public void MergeTest() { var epoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc); string uniqueName = ((DateTime.UtcNow - epoch).TotalSeconds).ToString(); string uniqueName2 = uniqueName + "_"; string failureMessage = string.Empty; UnAuthCredentials.Clear(); using (CognitoSyncManager sm1 = new CognitoSyncManager(AuthCredentials)) { sm1.WipeData(false); Thread.Sleep(2000); using (Dataset d = sm1.OpenOrCreateDataset("test")) { d.Put(uniqueName, uniqueName); d.OnSyncSuccess += delegate(object s1, SyncSuccessEventArgs e1) { UnAuthCredentials.Clear(); using (CognitoSyncManager sm2 = new CognitoSyncManager(UnAuthCredentials)) { Thread.Sleep(2000); using (Dataset d2 = sm2.OpenOrCreateDataset("test")) { d2.Put(uniqueName2, uniqueName2); d2.OnSyncSuccess += delegate(object s2, SyncSuccessEventArgs e2) { AuthCredentials.Clear(); UnAuthCredentials.Clear(); //now we will use auth credentials. using (CognitoSyncManager sm3 = new CognitoSyncManager(AuthCredentials)) { Thread.Sleep(2000); using (Dataset d3 = sm3.OpenOrCreateDataset("test")) { bool mergeTriggered = false; d3.OnSyncSuccess += (object sender, SyncSuccessEventArgs e) => { if (!mergeTriggered) { failureMessage += "Expecting DatasetMerged instead of OnSyncSuccess\n"; } }; d3.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); }; d3.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d3.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d3.OnDatasetMerged += (Dataset ds, List <string> datasetNames) => { mergeTriggered = true; return(true); }; #if BCL35 d3.Synchronize(); #else RunAsSync(async() => await d3.SynchronizeAsync()); #endif } } }; d2.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); }; d2.OnSyncConflict += (Dataset dataset, List <SyncConflict> conflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d2.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d2.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) => { failureMessage += "Not expecting OnDatasetMerged\n"; return(false); }; #if BCL35 d2.Synchronize(); #else RunAsSync(async() => await d2.SynchronizeAsync()); #endif } } }; d.OnSyncFailure += delegate(object s, SyncFailureEventArgs e) { failureMessage += string.Format("Not expecting OnSyncFailure Got exception {0}\n", e.Exception.Message); }; d.OnSyncConflict += (Dataset dataset, List <SyncConflict> syncConflicts) => { failureMessage += "Not expecting OnSyncConflict\n"; return(false); }; d.OnDatasetDeleted += (Dataset dataset) => { failureMessage += "Not expecting OnDatasetDeleted\n"; return(false); }; d.OnDatasetMerged += (Dataset dataset, List <string> datasetNames) => { failureMessage += "Not expecting OnDatasetMerged\n"; return(false); }; #if BCL35 d.Synchronize(); #else RunAsSync(async() => await d.SynchronizeAsync()); #endif } } if (!string.IsNullOrEmpty(failureMessage)) { Assert.Fail(failureMessage); } }
/// <summary> /// Test case: Check that the dataset metadata is modified appropriately when calling Synchronize. /// We test for the dirty bit, the sync count and the last modified timmestamp. /// </summary> //[TestMethod] //[TestCategory("SyncManager")] public void MetadataTest() { string failureMessage = string.Empty; using (CognitoSyncManager syncManager = new CognitoSyncManager(UnAuthCredentials)) { syncManager.WipeData(false); using (Dataset d = syncManager.OpenOrCreateDataset("testDataset6")) { d.Put("testKey3", "the initial value"); //Initial properties var records = d.Records; Record r = d.Records[records.Count - 1]; long initialSyncCount = r.SyncCount; bool initialDirty = r.IsModified; DateTime initialDate = r.DeviceLastModifiedDate.Value; d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e) { //Properties after Synchronize Record r2 = d.Records[records.Count - 1]; long synchronizedSyncCount = r2.SyncCount; bool synchronizedDirty = r2.IsModified; DateTime synchronizedDate = r2.DeviceLastModifiedDate.Value; d.Put("testKey3", "a new value"); //Properties after changing the content again Record r3 = d.Records[records.Count - 1]; long finalSyncCount = r3.SyncCount; bool finalDirty = r3.IsModified; DateTime finalDate = r3.DeviceLastModifiedDate.Value; if (!initialDirty) { failureMessage += "Expected 'initialDirty' to be true\n"; } if (synchronizedDirty) { failureMessage += "Expected 'synchronizedDirty' to be false\n"; } if (!finalDirty) { failureMessage += "Expected 'finalDirty' to be true\n"; } if (synchronizedSyncCount <= initialSyncCount) { failureMessage += "Expected synchronizedSyncCount > initialSyncCount\n"; } if (synchronizedSyncCount != finalSyncCount) { failureMessage += "Expected synchronizedSyncCount == finalSyncCount\n"; } if (finalDate <= initialDate) { failureMessage += "Expected finalDate > initialDate\n"; } if (initialDate != synchronizedDate) { failureMessage += "Expected initialDate == synchronizedDate\n"; } }; d.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += e.Exception.ToString() + "\n"; }; #if BCL35 d.Synchronize(); #else RunAsSync(async() => await d.SynchronizeAsync()); #endif if (!string.IsNullOrEmpty(failureMessage)) { Assert.Fail(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); } }
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); }
public void MetadataTest() { 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); using (Dataset d = syncManager.OpenOrCreateDataset("testDataset6")) { d.Put("testKey3", "the initial value"); //Initial properties var records = d.Records; Record r = d.Records[records.Count - 1]; long initialSyncCount = r.SyncCount; bool initialDirty = r.IsModified; DateTime initialDate = r.DeviceLastModifiedDate.Value; d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e) { //Properties after Synchronize Record r2 = d.Records[records.Count - 1]; long synchronizedSyncCount = r2.SyncCount; bool synchronizedDirty = r2.IsModified; DateTime synchronizedDate = r2.DeviceLastModifiedDate.Value; d.Put("testKey3", "a new value"); //Properties after changing the content again Record r3 = d.Records[records.Count - 1]; long finalSyncCount = r3.SyncCount; bool finalDirty = r3.IsModified; DateTime finalDate = r3.DeviceLastModifiedDate.Value; if (!initialDirty) { failureMessage += "Expected 'initialDirty' to be true\n"; } if (synchronizedDirty) { failureMessage += "Expected 'synchronizedDirty' to be false\n"; } if (!finalDirty) { failureMessage += "Expected 'finalDirty' to be true\n"; } if (synchronizedSyncCount <= initialSyncCount) { failureMessage += "Expected synchronizedSyncCount > initialSyncCount\n"; } if (synchronizedSyncCount != finalSyncCount) { failureMessage += "Expected synchronizedSyncCount == finalSyncCount\n"; } if (finalDate <= initialDate) { failureMessage += "Expected finalDate > initialDate\n"; } if (initialDate != synchronizedDate) { Debug.LogWarning(initialDate); Debug.LogWarning(synchronizedDate); failureMessage += "Expected initialDate == synchronizedDate\n"; } ars.Set(); }; d.OnSyncFailure += (object sender, SyncFailureEventArgs e) => { failureMessage += e.Exception.ToString() + "\n"; ars.Set(); }; d.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); } syncManager.Dispose(); Utils.AssertStringIsNullOrEmpty(failureMessage); }
public void WipeDataTest() { 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("testDataset5"); Dataset d2 = null; d.Put("testKey", "testValue"); d.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts) { failureMessage += "Expecting SyncSuccess instead of SyncConflict\n"; return(false); }; d.OnSyncFailure += delegate(object sender, SyncFailureEventArgs e) { failureMessage += "Expecting SyncSuccess instead of SyncFailure\n"; ars.Set(); }; d.OnSyncSuccess += delegate(object sender, SyncSuccessEventArgs e) { syncManager.WipeData(); d2 = syncManager.OpenOrCreateDataset("testDataset5"); if (d2.Records.Count != 0) { failureMessage += "Expecting dataset to be empty due to local data wipe.\n"; } d2.Put("testKey", "newTestValue"); d2.OnSyncConflict += delegate(Dataset dataset, List <SyncConflict> conflicts) { failureMessage += "Expecting SyncSuccess instead of SyncConflict\n"; return(false); }; d2.OnSyncFailure += delegate(object sender2, SyncFailureEventArgs e2) { failureMessage += "Expecting SyncSuccess instead of SyncFailure\n"; ars.Set(); }; d2.OnSyncSuccess += delegate(object sender2, SyncSuccessEventArgs e2) { if (d2.Get("testKey") != "newTestValue") { failureMessage += "Value for key 'testKey' should be 'newTestValue'\n"; } ars.Set(); }; d2.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); }; d.SynchronizeAsync(new AsyncOptions { ExecuteCallbackOnMainThread = false }); ars.WaitOne(); syncManager.Dispose(); d.Dispose(); if (d2 != null) { d2.Dispose(); } Utils.AssertStringIsNullOrEmpty(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); }