Exemplo n.º 1
0
        public void UserDataApi()
        {
            string TEST_KEY = "testCounter";

            ClientModels.UserDataRecord testCounter;
            int testCounterValueExpected, testCounterValueActual;

            var getRequest   = new ClientModels.GetUserDataRequest();
            var getDataTask1 = PlayFabClientAPI.GetUserDataAsync(getRequest);

            getDataTask1.Wait();
            UUnitAssert.Null(getDataTask1.Result.Error, "UserData should have been retrieved from Api call");
            UUnitAssert.NotNull(getDataTask1.Result.Result, "UserData should have been retrieved from Api call");
            UUnitAssert.NotNull(getDataTask1.Result.Result.Data, "UserData should have been retrieved from Api call");
            if (!getDataTask1.Result.Result.Data.TryGetValue(TEST_KEY, out testCounter))
            {
                testCounter       = new ClientModels.UserDataRecord();
                testCounter.Value = "0";
            }
            int.TryParse(testCounter.Value, out testCounterValueExpected);
            testCounterValueExpected = (testCounterValueExpected + 1) % 100; // This test is about the expected value changing - but not testing more complicated issues like bounds

            var updateRequest = new ClientModels.UpdateUserDataRequest();

            updateRequest.Data           = new Dictionary <string, string>();
            updateRequest.Data[TEST_KEY] = testCounterValueExpected.ToString();
            var updateTask = PlayFabClientAPI.UpdateUserDataAsync(updateRequest);

            updateTask.Wait(); // The update doesn't return anything interesting except versionID.  It's better to just re-call GetUserData again below to verify the update
            UUnitAssert.Null(updateTask.Result.Error, "UpdateUserData call failed");
            UUnitAssert.NotNull(updateTask.Result.Result, "UpdateUserData call failed");

            getRequest = new ClientModels.GetUserDataRequest();
            var getDataTask2 = PlayFabClientAPI.GetUserDataAsync(getRequest);

            getDataTask2.Wait();
            UUnitAssert.Null(getDataTask2.Result.Error, "UserData should have been retrieved from Api call");
            UUnitAssert.NotNull(getDataTask2.Result.Result, "UserData should have been retrieved from Api call");
            UUnitAssert.NotNull(getDataTask2.Result.Result.Data, "UserData should have been retrieved from Api call");
            getDataTask2.Result.Result.Data.TryGetValue(TEST_KEY, out testCounter);
            UUnitAssert.NotNull(testCounter, "The updated UserData was not found in the Api results");
            int.TryParse(testCounter.Value, out testCounterValueActual);
            UUnitAssert.Equals(testCounterValueExpected, testCounterValueActual);

            var timeUpdated = testCounter.LastUpdated;
            var testMin     = DateTime.UtcNow - TimeSpan.FromMinutes(5);
            var testMax     = testMin + TimeSpan.FromMinutes(10);

            UUnitAssert.True(testMin <= timeUpdated && timeUpdated <= testMax);
        }
        public void CloudScript()
        {
            if (string.IsNullOrEmpty(Client.Settings.GetLogicURL()))
            {
                var getUrlTask = Client.GetCloudScriptUrlAsync(new ClientModels.GetCloudScriptUrlRequest());

                try
                {
                    getUrlTask.Wait();
                }
                catch (Exception ex)
                {
                    UUnitAssert.True(false, ex.Message);
                }
                UUnitAssert.False(string.IsNullOrEmpty(getUrlTask.Result), "Failed to get LogicServerURL");
                UUnitAssert.False(string.IsNullOrEmpty(Client.Settings.GetLogicURL()), "Failed to get LogicServerURL");
            }

            var request = new ClientModels.RunCloudScriptRequest();

            request.ActionId = "helloWorld";
            var cloudTask = Client.RunCloudScriptAsync(request);

            try
            {
                cloudTask.Wait();
            }
            catch (Exception ex)
            {
                UUnitAssert.True(false, ex.Message);
            }
            UUnitAssert.NotNull(cloudTask.Result, "Failed to Execute CloudScript");
            UUnitAssert.False(string.IsNullOrEmpty(cloudTask.Result.ResultsEncoded), "Failed to Execute CloudScript");

            // Get the helloWorld return message
            JObject jobj = cloudTask.Result.Results as JObject;

            UUnitAssert.NotNull(jobj);
            JToken jtok;

            jobj.TryGetValue("messageValue", out jtok);
            UUnitAssert.NotNull(jtok);
            JValue jval = jtok as JValue;

            UUnitAssert.NotNull(jval);
            string actualMessage = jval.Value as string;

            UUnitAssert.Equals("Hello " + playFabId + "!", actualMessage);
        }
        public void LoginWithAdvertisingId()
        {
            PlayFabSettings.AdvertisingIdType  = PlayFabSettings.AD_TYPE_ANDROID_ID;
            PlayFabSettings.AdvertisingIdValue = "PlayFabTestId";

            var loginRequest = new ClientModels.LoginWithEmailAddressRequest();

            loginRequest.Email    = USER_EMAIL;
            loginRequest.Password = USER_PASSWORD;
            loginRequest.TitleId  = PlayFabSettings.TitleId;
            PlayFabClientAPI.LoginWithEmailAddress(loginRequest, LoginCallback, SharedErrorCallback);
            WaitForApiCalls();

            UUnitAssert.Equals(PlayFabSettings.AD_TYPE_ANDROID_ID + "_Successful", PlayFabSettings.AdvertisingIdType);
        }
Exemplo n.º 4
0
        public void UserStatisticsApi()
        {
            int testStatExpected, testStatActual;

            var getRequest   = new ClientModels.GetUserStatisticsRequest();
            var getStatTask1 = PlayFabClientAPI.GetUserStatisticsAsync(getRequest);

            getStatTask1.Wait();
            UUnitAssert.Null(getStatTask1.Result.Error, "UserStatistics should have been retrieved from Api call");
            UUnitAssert.NotNull(getStatTask1.Result.Result, "UserStatistics should have been retrieved from Api call");
            UUnitAssert.NotNull(getStatTask1.Result.Result.UserStatistics, "UserStatistics should have been retrieved from Api call");
            if (!getStatTask1.Result.Result.UserStatistics.TryGetValue(TEST_STAT_NAME, out testStatExpected))
            {
                testStatExpected = TEST_STAT_BASE;
            }
            testStatExpected = ((testStatExpected + 1) % TEST_STAT_BASE) + TEST_STAT_BASE; // This test is about the expected value changing (incrementing through from TEST_STAT_BASE to TEST_STAT_BASE * 2 - 1)

            var updateRequest = new ClientModels.UpdateUserStatisticsRequest();

            updateRequest.UserStatistics = new Dictionary <string, int>();
            updateRequest.UserStatistics[TEST_STAT_NAME] = testStatExpected;
            var updateTask = PlayFabClientAPI.UpdateUserStatisticsAsync(updateRequest);

            updateTask.Wait(); // The update doesn't return anything, so can't test anything other than failure

            // Test update result - no data returned, so error or no error, based on Title settings
            if (!TITLE_CAN_UPDATE_SETTINGS)
            {
                UUnitAssert.Null(updateTask.Result.Result, "UpdateStatistics should have failed");
                UUnitAssert.NotNull(updateTask.Result.Error, "UpdateStatistics should have failed");
                return; // The rest of this tests changing settings - Which we verified we cannot do
            }
            else // if (CAN_UPDATE_SETTINGS)
            {
                UUnitAssert.Null(updateTask.Result.Error, "UpdateStatistics call failed");
                UUnitAssert.NotNull(updateTask.Result.Result, "UpdateStatistics call failed");
            }

            getRequest = new ClientModels.GetUserStatisticsRequest();
            var getStatTask2 = PlayFabClientAPI.GetUserStatisticsAsync(getRequest);

            getStatTask2.Wait();
            UUnitAssert.Null(getStatTask2.Result.Error, "UserStatistics should have been retrieved from Api call");
            UUnitAssert.NotNull(getStatTask2.Result.Result, "UserStatistics should have been retrieved from Api call");
            UUnitAssert.NotNull(getStatTask2.Result.Result.UserStatistics, "UserStatistics should have been retrieved from Api call");
            getStatTask2.Result.Result.UserStatistics.TryGetValue(TEST_STAT_NAME, out testStatActual);
            UUnitAssert.Equals(testStatExpected, testStatActual);
        }
        private void CloudScript()
        {
            if (string.IsNullOrEmpty(PlayFabSettings.LogicServerUrl))
            {
                PlayFabClientAPI.GetCloudScriptUrl(new GetCloudScriptUrlRequest(), CloudScriptUrlCallback, SharedErrorCallback);
                WaitForApiCalls();
                UUnitAssert.True(lastReceivedMessage.StartsWith("CloudScript setup complete: "), lastReceivedMessage);
            }

            var request = new RunCloudScriptRequest();

            request.ActionId = "helloWorld";
            PlayFabClientAPI.RunCloudScript(request, CloudScriptHwCallback, SharedErrorCallback);
            WaitForApiCalls();
            UUnitAssert.Equals("Hello " + playFabId + "!", lastReceivedMessage);
        }
Exemplo n.º 6
0
        public void LoginWithAdvertisingId()
        {
            PlayFabSettings.AdvertisingIdType  = PlayFabSettings.AD_TYPE_ANDROID_ID;
            PlayFabSettings.AdvertisingIdValue = "PlayFabTestId";

            var loginRequest = new ClientModels.LoginWithEmailAddressRequest();

            loginRequest.Email    = USER_EMAIL;
            loginRequest.Password = USER_PASSWORD;
            loginRequest.TitleId  = PlayFabSettings.TitleId;
            var loginTask = PlayFabClientAPI.LoginWithEmailAddressAsync(loginRequest);

            loginTask.Wait();

            UUnitAssert.Equals(PlayFabSettings.AD_TYPE_ANDROID_ID + "_Successful", PlayFabSettings.AdvertisingIdType);
        }
        public void LoginWithAdvertisingId()
        {
            Client.Settings.AdvertisingIdType  = PlayFabDefaultSettings.AD_TYPE_ANDROID_ID;
            Client.Settings.AdvertisingIdValue = "PlayFabTestId";

            var loginTask = Client.LoginWithEmailAddressAsync(Client.Settings.TitleId, USER_EMAIL, USER_PASSWORD);

            try
            {
                loginTask.Wait();
            }
            catch (Exception ex)
            {
                UUnitAssert.True(false, ex.Message);
            }
            UUnitAssert.Equals(PlayFabDefaultSettings.AD_TYPE_ANDROID_ID + "_Successful", Client.Settings.AdvertisingIdType);
        }
        public void UserDataApi()
        {
            int testCounterValueExpected, testCounterValueActual;

            var getRequest = new GetUserDataRequest();

            PlayFabClientAPI.GetUserData(getRequest, GetUserDataCallback, SharedErrorCallback);
            WaitForApiCalls();

            UUnitAssert.Equals("User Data Received", lastReceivedMessage);
            int.TryParse(testCounterReturn.Value, out testCounterValueExpected);
            testCounterValueExpected = (testCounterValueExpected + 1) % 100; // This test is about the expected value changing - but not testing more complicated issues like bounds

            var updateRequest = new UpdateUserDataRequest();

            updateRequest.Data = new Dictionary <string, string>();
            updateRequest.Data[TEST_DATA_KEY] = testCounterValueExpected.ToString();
            PlayFabClientAPI.UpdateUserData(updateRequest, UpdateUserDataCallback, SharedErrorCallback);
            WaitForApiCalls();

            UUnitAssert.StringEquals("User Data Updated", lastReceivedMessage);

            getRequest = new GetUserDataRequest();
            PlayFabClientAPI.GetUserData(getRequest, GetUserDataCallback, SharedErrorCallback);
            WaitForApiCalls();

            UUnitAssert.StringEquals("User Data Received", lastReceivedMessage);
            int.TryParse(testCounterReturn.Value, out testCounterValueActual);
            UUnitAssert.IntEquals(testCounterValueExpected, testCounterValueActual);

            DateTime timeUpdated = testCounterReturn.LastUpdated;
            DateTime minTest     = DateTime.UtcNow - TimeSpan.FromMinutes(5);
            DateTime maxTest     = DateTime.UtcNow + TimeSpan.FromMinutes(5);

            UUnitAssert.True(minTest <= timeUpdated && timeUpdated <= maxTest);

            // UnityEngine.Debug.Log((DateTime.UtcNow - timeUpdated).TotalSeconds);
            UUnitAssert.True(Math.Abs((DateTime.UtcNow - timeUpdated).TotalMinutes) < 5); // Make sure that this timestamp is recent - This must also account for the difference between local machine time and server time
        }
        public void UserStatisticsApi()
        {
            int testStatExpected, testStatActual;

            var getRequest = new GetUserStatisticsRequest();

            PlayFabClientAPI.GetUserStatistics(getRequest, GetUserStatsCallback, SharedErrorCallback);
            WaitForApiCalls();

            UUnitAssert.Equals("User Stats Received", lastReceivedMessage);
            testStatExpected = ((testStatReturn + 1) % TEST_STAT_BASE) + TEST_STAT_BASE; // This test is about the expected value changing (incrementing through from TEST_STAT_BASE to TEST_STAT_BASE * 2 - 1)

            var updateRequest = new UpdateUserStatisticsRequest();

            updateRequest.UserStatistics = new Dictionary <string, int>();
            updateRequest.UserStatistics[TEST_STAT_NAME] = testStatExpected;
            PlayFabClientAPI.UpdateUserStatistics(updateRequest, UpdateUserStatsCallback, SharedErrorCallback);
            WaitForApiCalls();

            // Test update result - no data returned, so error or no error, based on Title settings
            if (!TITLE_CAN_UPDATE_SETTINGS)
            {
                UUnitAssert.Equals("error message from PlayFab", lastReceivedMessage);
                return; // The rest of this tests changing settings - Which we verified we cannot do
            }
            else // if (CAN_UPDATE_SETTINGS)
            {
                UUnitAssert.Equals("User Stats Updated", lastReceivedMessage);
            }

            getRequest = new GetUserStatisticsRequest();
            PlayFabClientAPI.GetUserStatistics(getRequest, GetUserStatsCallback, SharedErrorCallback);
            WaitForApiCalls();

            UUnitAssert.Equals("User Stats Received", lastReceivedMessage);
            testStatActual = testStatReturn;
            UUnitAssert.Equals(testStatExpected, testStatActual);
        }
Exemplo n.º 10
0
        public void LeaderBoard()
        {
            var clientRequest = new ClientModels.GetLeaderboardAroundCurrentUserRequest();

            clientRequest.MaxResultsCount = 3;
            clientRequest.StatisticName   = TEST_STAT_NAME;
            PlayFabClientAPI.GetLeaderboardAroundCurrentUser(clientRequest, GetClientLbCallback, SharedErrorCallback);
            WaitForApiCalls();

            UUnitAssert.Equals("Get Client Leaderboard Successful", lastReceivedMessage);
            // Testing anything more would be testing actual functionality of the Leaderboard, which is outside the scope of this test.

            var serverRequest = new ServerModels.GetLeaderboardAroundCharacterRequest();

            serverRequest.MaxResultsCount = 3;
            serverRequest.StatisticName   = TEST_STAT_NAME;
            serverRequest.CharacterId     = characterId;
            serverRequest.PlayFabId       = playFabId;
            PlayFabServerAPI.GetLeaderboardAroundCharacter(serverRequest, GetServerLbCallback, SharedErrorCallback);
            WaitForApiCalls();

            UUnitAssert.Equals("Get Server Leaderboard Successful", lastReceivedMessage);
        }
        public void UserStatisticsApi()
        {
            int testStatExpected, testStatActual;

            var getStatTask1 = Client.GetUserStatisticsAsync();

            try
            {
                getStatTask1.Wait();
            }
            catch (Exception ex)
            {
                UUnitAssert.True(false, ex.Message);
            }

            UUnitAssert.NotNull(getStatTask1.Result, "UserStatistics should have been retrieved from Api call");

            if (!getStatTask1.Result.TryGetValue(TEST_STAT_NAME, out testStatExpected))
            {
                testStatExpected = TEST_STAT_BASE;
            }
            testStatExpected = ((testStatExpected + 1) % TEST_STAT_BASE) + TEST_STAT_BASE; // This test is about the expected value changing (incrementing through from TEST_STAT_BASE to TEST_STAT_BASE * 2 - 1)

            var updateRequest = new ClientModels.UpdateUserStatisticsRequest();

            updateRequest.UserStatistics = new Dictionary <string, int>();
            updateRequest.UserStatistics[TEST_STAT_NAME] = testStatExpected;
            var    updateTask    = Client.UpdateUserStatisticsAsync(updateRequest);
            bool   failed        = false;
            string failedMessage = "UpdateStatistics should have failed";

            try
            {
                updateTask.Wait(); // The update doesn't return anything, so can't test anything other than failure
            }
            catch (Exception ex)
            {
                failed        = true;
                failedMessage = ex.Message;
            }

            // Test update result - no data returned, so error or no error, based on Title settings
            if (!TITLE_CAN_UPDATE_SETTINGS)
            {
                UUnitAssert.True(failed, failedMessage);
            }
            else
            {
                UUnitAssert.False(failed, failedMessage);
            }

            var getStatTask2 = Client.GetUserStatisticsAsync();

            try
            {
                getStatTask2.Wait();
            }
            catch (Exception ex)
            {
                UUnitAssert.True(false, ex.Message);
            }
            UUnitAssert.NotNull(getStatTask2.Result, "UserStatistics should have been retrieved from Api call");
            getStatTask2.Result.TryGetValue(TEST_STAT_NAME, out testStatActual);
            UUnitAssert.Equals(testStatExpected, testStatActual);
        }