public void LeaderBoard()
{
var clientRequest = new ClientModels.GetLeaderboardRequest();
clientRequest.MaxResultsCount = 3;
clientRequest.StatisticName = TEST_STAT_NAME;
var clientTask = PlayFabClientAPI.GetLeaderboardAsync(clientRequest);
clientTask.Wait();
UUnitAssert.Null(clientTask.Result.Error, "Failed to get client leaderboard");
UUnitAssert.NotNull(clientTask.Result.Result, "Failed to get client leaderboard");
UUnitAssert.NotNull(clientTask.Result.Result.Leaderboard, "Failed to get client leaderboard");
UUnitAssert.True(clientTask.Result.Result.Leaderboard.Count > 0, "Leaderboard does not contain enough entries.");
var serverRequest = new ServerModels.GetLeaderboardRequest();
serverRequest.MaxResultsCount = 3;
serverRequest.StatisticName = TEST_STAT_NAME;
var serverTask = PlayFabServerAPI.GetLeaderboardAsync(serverRequest);
clientTask.Wait();
UUnitAssert.Null(serverTask.Result.Error, "Failed to get server leaderboard");
UUnitAssert.NotNull(serverTask.Result.Result, "Failed to get server leaderboard");
UUnitAssert.NotNull(serverTask.Result.Result.Leaderboard, "Failed to get server leaderboard");
UUnitAssert.True(serverTask.Result.Result.Leaderboard.Count > 0, "Leaderboard does not contain enough entries.");
}
public void CloudScript()
{
var getUrlTask = PlayFabClientAPI.GetCloudScriptUrlAsync(new GetCloudScriptUrlRequest());
WaitForResultSuccess(getUrlTask, "Failed to get LogicServerURL");
var request = new RunCloudScriptRequest();
request.ActionId = "helloWorld";
var cloudTask = PlayFabClientAPI.RunCloudScriptAsync(request);
WaitForResultSuccess(cloudTask, "Failed to Execute CloudScript");
UUnitAssert.False(string.IsNullOrEmpty(cloudTask.Result.Result.ResultsEncoded), "Failed to Execute CloudScript");
// Get the helloWorld return message
JObject jobj = cloudTask.Result.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.StringEquals("Hello " + playFabId + "!", actualMessage);
}
public void UserCharacter()
{
var request = new ServerModels.ListUsersCharactersRequest();
request.PlayFabId = playFabId; // Received from client upon login
PlayFabServerAPI.GetAllUsersCharacters(request, GetCharsCallback, SharedErrorCallback);
WaitForApiCalls();
UUnitAssert.StringEquals("Get Chars Successful", lastReceivedMessage);
// The target character may not exist, but we don't fail, since we can create it below
if (targetCharacter == null)
{
// Create the targetCharacter since it doesn't exist
var grantRequest = new ServerModels.GrantCharacterToUserRequest();
grantRequest.PlayFabId = playFabId;
grantRequest.CharacterName = CHAR_NAME;
grantRequest.CharacterType = CHAR_TEST_TYPE;
PlayFabServerAPI.GrantCharacterToUser(grantRequest, GrantCharCallback, SharedErrorCallback);
WaitForApiCalls();
UUnitAssert.StringEquals("Grant Char Successful", lastReceivedMessage);
// Attempt to get characters again
PlayFabServerAPI.GetAllUsersCharacters(request, GetCharsCallback, SharedErrorCallback);
WaitForApiCalls();
UUnitAssert.StringEquals("Get Chars Successful", lastReceivedMessage);
}
// Save the requested character
UUnitAssert.NotNull(targetCharacter, "The test character did not exist, and was not successfully created");
}
public void LeaderBoard()
{
var clientTask = Client.GetLeaderboardAsync(TEST_STAT_NAME, 0, 3);
try
{
clientTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(clientTask.Result, "Failed to get client leaderboard");
UUnitAssert.True(clientTask.Result.Leaderboard.Count > 0, "Leaderboard does not contain enough entries.");
var serverTask = Server.GetLeaderboardAsync(TEST_STAT_NAME, 0, 3);
try
{
clientTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(serverTask.Result, "Failed to get server leaderboard");
UUnitAssert.True(serverTask.Result.Leaderboard.Count > 0, "Leaderboard does not contain enough entries.");
}
public void UserCharacter()
{
var getCharsTask = Server.GetAllUsersCharactersAsync(_playFabId);
try
{
getCharsTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(getCharsTask.Result, "Failed to GetChars");
ServerModels.CharacterResult targetCharacter = null;
foreach (var eachCharacter in getCharsTask.Result)
{
if (eachCharacter.CharacterName == CHAR_NAME)
{
targetCharacter = eachCharacter;
}
}
if (targetCharacter == null)
{
// Create the targetCharacter since it doesn't exist
var grantTask = Server.GrantCharacterToUserAsync(_playFabId, CHAR_NAME, CHAR_TEST_TYPE);
try
{
grantTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(grantTask.Result, "Grant character failed");
// Attempt to get characters again
getCharsTask = Server.GetAllUsersCharactersAsync(_playFabId);
try
{
getCharsTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(getCharsTask.Result, "Failed to GetChars");
foreach (var eachCharacter in getCharsTask.Result)
{
if (eachCharacter.CharacterName == CHAR_NAME)
{
targetCharacter = eachCharacter;
}
}
}
// Save the requested character
UUnitAssert.NotNull(targetCharacter, "The test character did not exist, and was not successfully created");
}
private static void WaitForResultSuccess <TResult>(Task <PlayFabResult <TResult> > task, string failMessage) where TResult : PlayFabResultCommon
{
task.Wait();
UUnitAssert.NotNull(task.Result, failMessage);
UUnitAssert.IsNull(task.Result.Error, failMessage);
UUnitAssert.NotNull(task.Result.Result, failMessage);
}
public void CloudScript()
{
var cloudTask = Client.ExecuteCloudScriptAsync("helloWorld");
try
{
cloudTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(cloudTask.Result, "Failed to Execute CloudScript");
UUnitAssert.NotNull(cloudTask.Result.FunctionResult, "Failed to Execute CloudScript");
// Get the helloWorld return message
var jobj = (JObject)cloudTask.Result.FunctionResult;
UUnitAssert.NotNull(jobj);
JToken jtok;
jobj.TryGetValue("messageValue", out jtok);
UUnitAssert.NotNull(jtok);
var jval = jtok as JValue;
UUnitAssert.NotNull(jval);
var actualMessage = jval.Value as string;
UUnitAssert.StringEquals("Hello " + _playFabId + "!", actualMessage);
}
private void CloudScriptHwCallback(RunCloudScriptResult result)
{
UUnitAssert.NotNull(result.ResultsEncoded);
UUnitAssert.NotNull(result.Results);
var jobj = result.Results as JsonObject;
lastReceivedMessage = jobj["messageValue"] as string;
}
private void WaitForApiCalls()
{
lastReceivedMessage = null;
while (PlayFabHTTP.instance.GetPendingMessages() != 0)
{
Thread.Sleep(1); // Wait for the threaded call to be executed
PlayFabHTTP.instance.Update(); // Invoke the callbacks for any threaded messages
}
UUnitAssert.NotNull(lastReceivedMessage);
}
public void UserCharacter()
{
var request = new ListUsersCharactersRequest();
request.PlayFabId = playFabId; // Received from client upon login
PlayFabClientAPI.GetAllUsersCharacters(request, GetCharsCallback, SharedErrorCallback);
WaitForApiCalls();
UUnitAssert.Equals("Get Chars Successful", lastReceivedMessage);
UUnitAssert.NotNull(targetCharacter, "The test character did not exist");
}
public void UserCharacter()
{
var request = new ServerModels.ListUsersCharactersRequest();
request.PlayFabId = playFabId; // Received from client upon login
var getCharsTask = PlayFabServerAPI.GetAllUsersCharactersAsync(request);
getCharsTask.Wait();
UUnitAssert.Null(getCharsTask.Result.Error, "Failed to GetChars");
UUnitAssert.NotNull(getCharsTask.Result.Result, "Failed to GetChars");
UUnitAssert.NotNull(getCharsTask.Result.Result.Characters, "Failed to GetChars");
ServerModels.CharacterResult targetCharacter = null;
foreach (var eachCharacter in getCharsTask.Result.Result.Characters)
{
if (eachCharacter.CharacterName == CHAR_NAME)
{
targetCharacter = eachCharacter;
}
}
if (targetCharacter == null)
{
// Create the targetCharacter since it doesn't exist
var grantRequest = new ServerModels.GrantCharacterToUserRequest();
grantRequest.PlayFabId = playFabId;
grantRequest.CharacterName = CHAR_NAME;
grantRequest.CharacterType = CHAR_TEST_TYPE;
var grantTask = PlayFabServerAPI.GrantCharacterToUserAsync(grantRequest);
grantTask.Wait();
UUnitAssert.Null(grantTask.Result.Error, "Grant character failed");
UUnitAssert.NotNull(grantTask.Result.Result, "Grant character failed");
UUnitAssert.NotNull(grantTask.Result.Result.CharacterId, "Grant character failed");
// Attempt to get characters again
getCharsTask = PlayFabServerAPI.GetAllUsersCharactersAsync(request);
getCharsTask.Wait();
UUnitAssert.Null(getCharsTask.Result.Error, "Failed to GetChars");
UUnitAssert.NotNull(getCharsTask.Result.Result, "Failed to GetChars");
UUnitAssert.NotNull(getCharsTask.Result.Result.Characters, "Failed to GetChars");
foreach (var eachCharacter in getCharsTask.Result.Result.Characters)
{
if (eachCharacter.CharacterName == CHAR_NAME)
{
targetCharacter = eachCharacter;
}
}
}
// Save the requested character
UUnitAssert.NotNull(targetCharacter, "The test character did not exist, and was not successfully created");
characterId = targetCharacter.CharacterId;
}
private void WaitForApiCalls()
{
lastReceivedMessage = null;
DateTime expireTime = DateTime.UtcNow + TimeSpan.FromSeconds(3);
while (PlayFabHTTP.GetPendingMessages() != 0 && DateTime.UtcNow < expireTime)
{
Thread.Sleep(1); // Wait for the threaded call to be executed
PlayFabHTTP.instance.Update(); // Invoke the callbacks for any threaded messages
}
UUnitAssert.True(DateTime.UtcNow < expireTime, "Request timed out");
UUnitAssert.NotNull(lastReceivedMessage, "Unexpected internal error within PlayFab api, or test suite");
}
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 AccountInfo()
{
ClientModels.GetAccountInfoRequest request = new ClientModels.GetAccountInfoRequest();
request.PlayFabId = playFabId;
var task = PlayFabClientAPI.GetAccountInfoAsync(request);
task.Wait();
UUnitAssert.Null(task.Result.Error, "Failed to get accountInfo");
UUnitAssert.NotNull(task.Result.Result, "Failed to get accountInfo");
UUnitAssert.NotNull(task.Result.Result.AccountInfo, "Failed to get accountInfo");
UUnitAssert.NotNull(task.Result.Result.AccountInfo.TitleInfo, "Failed to get accountInfo");
UUnitAssert.NotNull(task.Result.Result.AccountInfo.TitleInfo.Origination, "Failed to get Origination Enum");
UUnitAssert.True(Enum.IsDefined(typeof(ClientModels.UserOrigination), task.Result.Result.AccountInfo.TitleInfo.Origination.Value), "Origination Enum not valid");
}
public void CloudScriptError()
{
var request = new ExecuteCloudScriptRequest {
FunctionName = "throwError"
};
var cloudTask = PlayFabClientAPI.ExecuteCloudScriptAsync(request);
WaitForResultSuccess(cloudTask, "Failed to Execute CloudScript");
// Get the JavascriptException result
UUnitAssert.IsNull(cloudTask.Result.Result.FunctionResult);
UUnitAssert.NotNull(cloudTask.Result.Result.Error);
UUnitAssert.StringEquals(cloudTask.Result.Result.Error.Error, "JavascriptException");
}
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);
}
private void CloudScriptHwCallback(RunCloudScriptResult result)
{
UUnitAssert.NotNull(result.ResultsEncoded);
JObject jobj = 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);
lastReceivedMessage = jval.Value as string;
}
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);
}
public void InvalidLogin()
{
// If the setup failed to log in a user, we need to create one.
var request = new ClientModels.LoginWithEmailAddressRequest();
request.TitleId = PlayFabSettings.TitleId;
request.Email = USER_EMAIL;
request.Password = USER_PASSWORD + "INVALID";
var task = PlayFabClientAPI.LoginWithEmailAddressAsync(request);
task.Wait();
UUnitAssert.NotNull(task.Result);
UUnitAssert.Null(task.Result.Result);
UUnitAssert.NotNull(task.Result.Error);
UUnitAssert.True(task.Result.Error.ErrorMessage.Contains("password"));
}
public void CloudScriptError()
{
var cloudTask = Client.ExecuteCloudScriptAsync("throwError");
try
{
cloudTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
// Get the JavascriptException result
UUnitAssert.IsNull(cloudTask.Result.FunctionResult);
UUnitAssert.NotNull(cloudTask.Result.Error);
UUnitAssert.StringEquals(cloudTask.Result.Error.Error, "JavascriptException");
}
public void AccountInfo()
{
var task = Client.GetAccountInfoAsync(_playFabId);
try
{
task.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(task.Result, "Failed to get accountInfo");
UUnitAssert.NotNull(task.Result.TitleInfo, "Failed to get accountInfo");
UUnitAssert.NotNull(task.Result.TitleInfo.Origination, "Failed to get Origination Enum");
UUnitAssert.True(Enum.IsDefined(typeof(UserOrigination), task.Result.TitleInfo.Origination.Value), "Origination Enum not valid");
}
public void UserCharacter()
{
var request = new ServerModels.ListUsersCharactersRequest {
PlayFabId = _playFabId
};
var getCharsTask = PlayFabServerAPI.GetAllUsersCharactersAsync(request);
WaitForResultSuccess(getCharsTask, "Failed to GetChars");
ServerModels.CharacterResult targetCharacter = null;
foreach (var eachCharacter in getCharsTask.Result.Result.Characters)
{
if (eachCharacter.CharacterName == CHAR_NAME)
{
targetCharacter = eachCharacter;
}
}
if (targetCharacter == null)
{
// Create the targetCharacter since it doesn't exist
var grantRequest = new ServerModels.GrantCharacterToUserRequest
{
PlayFabId = _playFabId,
CharacterName = CHAR_NAME,
CharacterType = CHAR_TEST_TYPE,
};
var grantTask = PlayFabServerAPI.GrantCharacterToUserAsync(grantRequest);
WaitForResultSuccess(grantTask, "Grant character failed");
// Attempt to get characters again
getCharsTask = PlayFabServerAPI.GetAllUsersCharactersAsync(request);
WaitForResultSuccess(getCharsTask, "Failed to GetChars");
foreach (var eachCharacter in getCharsTask.Result.Result.Characters)
{
if (eachCharacter.CharacterName == CHAR_NAME)
{
targetCharacter = eachCharacter;
}
}
}
// Save the requested character
UUnitAssert.NotNull(targetCharacter, "The test character did not exist, and was not successfully created");
}
public void InvalidRegistration()
{
var registerRequest = new RegisterPlayFabUserRequest();
registerRequest.TitleId = PlayFabSettings.TitleId;
registerRequest.Username = "******";
registerRequest.Email = "x";
registerRequest.Password = "******";
var registerTask = PlayFabClientAPI.RegisterPlayFabUserAsync(registerRequest);
UUnitAssert.NotNull(registerTask.Result);
UUnitAssert.IsNull(registerTask.Result.Result);
UUnitAssert.NotNull(registerTask.Result.Error);
var expectedEmailMsg = "email address is not valid.";
var expectedPasswordMsg = "password must be between";
var fullReport = CompileErrorReport(registerTask.Result.Error);
UUnitAssert.True(fullReport.ToLower().Contains(expectedEmailMsg), "Expected an error about bad email address: " + fullReport);
UUnitAssert.True(fullReport.ToLower().Contains(expectedPasswordMsg), "Expected an error about bad password: " + fullReport);
}
public void LoginOrRegister()
{
if (!PlayFabClientAPI.IsClientLoggedIn()) // If we haven't already logged in...
{
var loginRequest = new ClientModels.LoginWithEmailAddressRequest();
loginRequest.Email = USER_EMAIL;
loginRequest.Password = USER_PASSWORD;
loginRequest.TitleId = PlayFabSettings.TitleId;
var loginTask = PlayFabClientAPI.LoginWithEmailAddressAsync(loginRequest);
loginTask.Wait();
if (loginTask.Result != null && loginTask.Result.Result != null) // If successful, track playFabId
{
playFabId = loginTask.Result.Result.PlayFabId; // Needed for subsequent tests
}
}
if (PlayFabClientAPI.IsClientLoggedIn())
{
return; // Success, already logged in
}
// If the setup failed to log in a user, we need to create one.
var registerRequest = new ClientModels.RegisterPlayFabUserRequest();
registerRequest.TitleId = PlayFabSettings.TitleId;
registerRequest.Username = USER_NAME;
registerRequest.Email = USER_EMAIL;
registerRequest.Password = USER_PASSWORD;
var registerTask = PlayFabClientAPI.RegisterPlayFabUserAsync(registerRequest);
registerTask.Wait();
UUnitAssert.NotNull(registerTask.Result);
UUnitAssert.Null(registerTask.Result.Error);
UUnitAssert.NotNull(registerTask.Result.Result);
playFabId = registerTask.Result.Result.PlayFabId; // Needed for subsequent tests
UUnitAssert.True(PlayFabClientAPI.IsClientLoggedIn(), "User login failed");
}
public void LeaderBoard()
{
var clientRequest = new ClientModels.GetLeaderboardAroundCurrentUserRequest();
clientRequest.MaxResultsCount = 3;
clientRequest.StatisticName = TEST_STAT_NAME;
var clientTask = Client.GetLeaderboardAroundCurrentUserAsync(clientRequest);
try
{
clientTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(clientTask.Result, "Failed to get client leaderboard");
UUnitAssert.True(clientTask.Result.Count > 0, "Leaderboard does not contain enough entries.");
var serverRequest = new ServerModels.GetLeaderboardAroundCharacterRequest();
serverRequest.MaxResultsCount = 3;
serverRequest.StatisticName = TEST_STAT_NAME;
serverRequest.CharacterId = characterId;
serverRequest.PlayFabId = playFabId;
var serverTask = Server.GetLeaderboardAroundCharacterAsync(serverRequest);
try
{
clientTask.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(serverTask.Result, "Failed to get server leaderboard");
UUnitAssert.True(serverTask.Result.Count > 0, "Leaderboard does not contain enough entries.");
}
public void CloudScript()
{
var request = new ExecuteCloudScriptRequest();
request.FunctionName = "helloWorld";
var cloudTask = PlayFabClientAPI.ExecuteCloudScriptAsync(request);
WaitForResultSuccess(cloudTask, "Failed to Execute CloudScript");
// Get the helloWorld return message
JObject jobj = cloudTask.Result.Result.FunctionResult 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.StringEquals("Hello " + playFabId + "!", actualMessage);
}
public void Run(UUnitTestResult testResult)
{
UUnitTestResult.TestState testState = UUnitTestResult.TestState.FAILED;
string message = null;
eachTestStopwatch.Reset();
setUpStopwatch.Reset();
tearDownStopwatch.Reset();
try
{
testResult.TestStarted();
setUpStopwatch.Start();
SetUp();
setUpStopwatch.Stop();
Type type = this.GetType();
MethodInfo method = type.GetRuntimeMethod(testMethodName, EMPTY_PARAMETER_TYPES); // Test methods must contain no parameters
UUnitAssert.NotNull(method, "Could not execute: " + testMethodName + ", it's probably not public."); // Limited access to loaded assemblies
eachTestStopwatch.Start();
((UUnitTestDelegate)method.CreateDelegate(typeof(UUnitTestDelegate), this))(); // This creates a delegate of the test function, and calls it
testState = UUnitTestResult.TestState.PASSED;
}
catch (UUnitAssertException e)
{
message = e.ToString();
testState = UUnitTestResult.TestState.FAILED;
}
catch (UUnitSkipException)
{
// message remains null
testState = UUnitTestResult.TestState.SKIPPED;
}
catch (TargetInvocationException e)
{
message = e.InnerException.ToString();
testState = UUnitTestResult.TestState.FAILED;
}
catch (Exception e)
{
message = e.ToString();
testState = UUnitTestResult.TestState.FAILED;
}
finally
{
eachTestStopwatch.Stop();
if (testState != UUnitTestResult.TestState.SKIPPED)
{
try
{
tearDownStopwatch.Start();
TearDown();
tearDownStopwatch.Stop();
}
catch (Exception e)
{
message = e.ToString();
testState = UUnitTestResult.TestState.FAILED;
}
}
}
testResult.TestComplete(testMethodName, testState, eachTestStopwatch.ElapsedMilliseconds, message);
}
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);
}
public void PlayerStatisticsApi()
{
int testStatExpected = 0, testStatActual = int.MinValue;
var getStatTask1 = Client.GetPlayerStatisticsAsync();
try
{
getStatTask1.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(getStatTask1.Result, "PlayerStatistics should have been retrieved from Api call");
foreach (var eachStat in getStatTask1.Result)
{
if (eachStat.StatisticName == TEST_STAT_NAME)
{
testStatExpected = eachStat.Value;
}
}
testStatExpected = (testStatExpected + 1) % 100; // This test is about the expected value changing (incrementing through from TEST_STAT_BASE to TEST_STAT_BASE * 2 - 1)
var updateTask = Client.UpdatePlayerStatisticsAsync(new List <StatisticUpdate> {
new StatisticUpdate {
StatisticName = TEST_STAT_NAME, Value = testStatExpected
}
});
try
{
updateTask.Wait(); // The update doesn't return anything, so can't test anything other than failure
}
catch (Exception ex)
{
UUnitAssert.Fail(ex.Message);
}
var getStatTask2 = Client.GetPlayerStatisticsAsync();
try
{
getStatTask2.Wait();
}
catch (Exception ex)
{
UUnitAssert.Fail(ex.Message);
}
UUnitAssert.NotNull(getStatTask2.Result, "PlayerStatistics should have been retrieved from Api call");
foreach (var eachStat in getStatTask2.Result)
{
if (eachStat.StatisticName == TEST_STAT_NAME)
{
testStatActual = eachStat.Value;
}
}
UUnitAssert.IntEquals(testStatExpected, testStatActual);
}
public void UserDataApi()
{
var TEST_KEY = "testCounter";
UserDataRecord testCounter;
int testCounterValueExpected, testCounterValueActual;
var getDataTask1 = Client.GetUserDataAsync();
try
{
getDataTask1.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(getDataTask1.Result, "UserData should have been retrieved from Api call");
UUnitAssert.NotNull(getDataTask1.Result.Data, "UserData should have been retrieved from Api call");
if (!getDataTask1.Result.Data.TryGetValue(TEST_KEY, out testCounter))
{
testCounter = new UserDataRecord {
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 updateTask = Client.UpdateUserDataAsync(new Dictionary <string, string> {
{ TEST_KEY, testCounterValueExpected.ToString() }
});
try
{
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
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(updateTask.Result, "UpdateUserData call failed");
var getDataTask2 = Client.GetUserDataAsync();
try
{
getDataTask2.Wait();
}
catch (Exception ex)
{
UUnitAssert.True(false, ex.Message);
}
UUnitAssert.NotNull(getDataTask2.Result, "UserData should have been retrieved from Api call");
UUnitAssert.NotNull(getDataTask2.Result.Data, "UserData should have been retrieved from Api call");
getDataTask2.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.IntEquals(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);
}
