Esempio n. 1
0
    /// <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);
        }
Esempio n. 3
0
    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();
    }
Esempio n. 4
0
        /// <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);
            }
        }
Esempio n. 5
0
    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
        });
    }
Esempio n. 6
0
 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> ();
 }
Esempio n. 7
0
        /// <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);
            }
        }
Esempio n. 8
0
        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);
        }
Esempio n. 9
0
 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();
 }
Esempio n. 10
0
 // 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();
 }
Esempio n. 11
0
        //[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);
                }
            }
        }
Esempio n. 12
0
 //[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
    }
Esempio n. 14
0
    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
        });
    }
Esempio n. 15
0
    // 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);
    }
Esempio n. 16
0
 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();
         }
     }
 }
Esempio n. 17
0
        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);
        }
Esempio n. 18
0
        // <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);
            }
        }
Esempio n. 19
0
        /// <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);
            }
        }
Esempio n. 20
0
        /// <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);
                    }
                }
            }
        }
Esempio n. 21
0
        /// <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);
            }
        }
Esempio n. 22
0
        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);
        }
Esempio n. 23
0
        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);
        }
Esempio n. 24
0
        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);
        }
Esempio n. 25
0
        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);
        }
Esempio n. 26
0
        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);
        }