public void LeaderboardRecordsFetch()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INLeaderboardRecord> res = null;
INError error = null;
var message = new NLeaderboardRecordsFetchMessage.Builder(serverLeaderboardId).Build();
client.Send(message, (INResultSet <INLeaderboardRecord> results) =>
{
res = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNotNull(res);
Assert.IsNotEmpty(res.Results);
Assert.GreaterOrEqual(res.Results.Count, 1);
Assert.IsNotEmpty(res.Results[0].Handle);
Assert.AreEqual(res.Results[0].Location, "San Francisco");
Assert.Greater(res.Results[0].NumScore, 0);
}
public void LeaderboardRecordsListHaystack()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INLeaderboardRecord> res = null;
var message = new NLeaderboardRecordsListMessage.Builder(serverLeaderboardId)
.FilterByPagingToOwnerId(self.Id)
.Limit(20)
.Build();
client.Send(message, (INResultSet <INLeaderboardRecord> results) =>
{
res = results;
evt.Set();
}, _ => {
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNotNull(res);
Assert.IsNotEmpty(res.Results);
Assert.GreaterOrEqual(res.Results.Count, 1);
Assert.IsNotEmpty(res.Results[0].Handle);
Assert.Greater(res.Results[0].NumScore, 0);
}
public void UpdateStorage()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INStorageKey> res = null;
var json = "{\"coins\": 100, \"gems\": 10, \"artifacts\": 0}";
var message = new NStorageUpdateMessage.Builder()
.Update(Bucket, Collection, Record, new NStorageUpdateMessage.StorageUpdateBuilder()
.Init("/foo", json) // make sure record is setup.
.Incr("/foo/coins", -10) // perform other updates to the record.
.Build())
.Build();
client.Send(message, (INResultSet <INStorageKey> results) =>
{
res = results;
evt.Set();
}, (INError err) => {
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNotNull(res);
Assert.IsNotEmpty(res.Results);
Assert.AreEqual(Bucket, res.Results[0].Bucket);
Assert.AreEqual(Collection, res.Results[0].Collection);
Assert.AreEqual(Record, res.Results[0].Record);
}
public void FetchStorage()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INStorageData> storageData = null;
INError error = null;
var message = new NStorageFetchMessage.Builder()
.Fetch(Bucket, Collection, Record, UserId)
.Build();
client.Send(message, (INResultSet <INStorageData> results) =>
{
storageData = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
evt.WaitOne(2000, false);
Assert.IsNull(error);
Assert.NotNull(storageData);
Assert.NotNull(storageData.Results);
Assert.AreEqual(storageData.Results.Count, 1);
Assert.NotNull(storageData.Results[0]);
Assert.AreEqual(storageData.Results[0].Bucket, Bucket);
Assert.AreEqual(storageData.Results[0].Collection, Collection);
Assert.AreEqual(storageData.Results[0].Record, Record);
Assert.AreEqual(storageData.Results[0].Value, StorageValue);
}
public void GroupsSelfList()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
INResultSet <INGroupSelf> groups = null;
var message = NGroupsSelfListMessage.Default();
client.Send(message, (INResultSet <INGroupSelf> results) =>
{
groups = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNull(error);
Assert.NotNull(groups);
Assert.NotNull(groups.Results);
Assert.AreEqual(1, groups.Results.Count);
Assert.NotNull(groups.Results[0]);
Assert.AreEqual(groups.Results[0].Id, myGroup.Id);
Assert.AreNotEqual(groups.Results[0].State, 2);
// Defined earlier on in GroupUpdate test
Assert.AreEqual(groups.Results[0].AvatarUrl, GroupDescription);
}
public void ListNotifications()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INNotification> res = null;
INError error = null;
var message = NNotificationsListMessage.Default(10);
client.Send(message, (INResultSet <INNotification> results) =>
{
res = results;
evt.Set();
}, (INError e) => {
error = e;
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNull(error);
Assert.IsNotNull(res);
Assert.IsTrue(res.Results.Count > 0);
Assert.IsNotNull(res.Cursor);
notifications = res.Results;
}
public void GroupsFetch()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
INResultSet <INGroup> groups = null;
var message = NGroupsFetchMessage.Builder.ById(FriendGroup.Id).Build();
client.Send(message, (INResultSet <INGroup> results) =>
{
groups = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNull(error);
Assert.NotNull(groups);
Assert.NotNull(groups.Results);
Assert.AreEqual(1, groups.Results.Count);
// Ensure only one group exists with the "fa" language.
Assert.AreEqual(groups.Results[0].Lang, "fa");
}
public void WriteStorageIfNoneMatchRejected()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INStorageKey> res = null;
INError error = null;
var message = new NStorageWriteMessage.Builder()
.Write(Bucket, Collection, Record, StorageValue, IfNoneMatchVersion)
.Build();
client.Send(message, (INResultSet <INStorageKey> results) =>
{
res = results;
evt.Set();
}, (INError e) => {
error = e;
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNull(res);
Assert.IsNotNull(error);
Assert.AreEqual(ErrorCode.StorageRejected, error.Code);
Assert.AreEqual("Storage write rejected: not found, version check failed, or permission denied", error.Message);
}
public void GroupsList()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
INResultSet <INGroup> groups = null;
var message = new NGroupsListMessage.Builder()
.OrderByAsc(true)
.FilterByLang("en")
.Build();
client.Send(message, (INResultSet <INGroup> results) =>
{
groups = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
evt.WaitOne(5000, false);
Assert.IsNull(error);
Assert.NotNull(groups);
Assert.NotNull(groups.Results);
Assert.Greater(groups.Results.Count, 1);
}
public void ListFriends()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INFriend> friends = null;
INError error = null;
var message = NFriendsListMessage.Default();
client.Send(message, (INResultSet <INFriend> results) =>
{
friends = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
evt.WaitOne(2000, false);
Assert.IsNull(error);
Assert.NotNull(friends);
Assert.NotNull(friends.Results);
Assert.IsTrue(friends.Results.Count == 1);
Assert.NotNull(friends.Results[0]);
Assert.IsTrue(friends.Results[0].Handle == FriendHandle);
}
private void OnMatchJoined(INResultSet <INMatch> matches)
{
if (matches != null)
{
_matchJoined = true;
self = matches.Results[0].Self;
nakamaMatchPresences.AddRange(matches.Results[0].Presence);
nakamaMatchPresences.Remove(nakamaMatchPresences.Single(x => x.Handle == self.Handle));
}
}
public void FetchUsers()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INUser> users = null;
var message = NUsersFetchMessage.ById(session.Id);
client.Send(message, (INResultSet <INUser> results) => {
users = results;
evt.Set();
}, _ => {
evt.Set();
});
evt.WaitOne(1000, false);
Assert.NotNull(users);
Assert.IsTrue(users.Results.Count == 1);
Assert.NotNull(users.Results[0]);
}
public void ReadPublicStorageOtherUsers()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INStorageData> storageData = null;
INError error = null;
var client2 = new NClient.Builder(DefaultServerKey).Build();
var regMessage = NAuthenticateMessage.Custom(CustomId);
client2.Register(regMessage, (INSession friendSession) =>
{
client2.Connect(friendSession);
var message = new NStorageFetchMessage.Builder()
.Fetch(Bucket, Collection, Record, UserId)
.Build();
client2.Send(message, (INResultSet <INStorageData> results) =>
{
storageData = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
}, (INError err) => {
error = err;
evt.Set();
});
evt.WaitOne(2000, false);
Assert.IsNull(error);
Assert.NotNull(storageData);
Assert.NotNull(storageData.Results);
Assert.AreEqual(1, storageData.Results.Count);
Assert.NotNull(storageData.Results[0]);
Assert.AreEqual(Bucket, storageData.Results[0].Bucket);
Assert.AreEqual(Collection, storageData.Results[0].Collection);
Assert.AreEqual(Record, storageData.Results[0].Record);
Assert.AreEqual(StorageValue, storageData.Results[0].Value);
}
public void LeaderboardsList()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INLeaderboard> res = null;
var message = new NLeaderboardsListMessage.Builder().Add(LeaderboardIdName).Build();
client.Send(message, (INResultSet <INLeaderboard> results) =>
{
res = results;
evt.Set();
}, _ => {
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNotNull(res);
Assert.IsNotEmpty(res.Results);
Assert.AreEqual(res.Results[0].Id, LeaderboardId);
Assert.GreaterOrEqual(res.Results[0].Count, 0);
}
void OnMatchJoined(INResultSet <INMatch> matchListWithOneEntry)
{
Debug.Log("Match Joined");
matchId = matchListWithOneEntry.Results[0].Id;
Debug.LogFormat("Join Match Id: {0}", matchId);
// get connected users
connectedOpponents = new List <INUserPresence>();
// Add list of connected opponents.
connectedOpponents.AddRange(matchListWithOneEntry.Results[0].Presence);
client.OnMatchData = (md) => {
if (OnDataReceived != null)
{
OnDataReceived(md);
}
};
// lock(connectedOpponents){
// LogOpponents(connectedOpponents, localPlayerId, "Joined");
// }
}
public void GroupUsersList()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
INResultSet <INGroupUser> groupUsers = null;
var message = NGroupUsersListMessage.Default(FriendGroup.Id);
client.Send(message, (INResultSet <INGroupUser> results) => {
groupUsers = results;
evt.Set();
}, (INError err) =>
{
error = err;
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNull(error);
Assert.NotNull(groupUsers);
Assert.NotNull(groupUsers.Results);
Assert.AreEqual(2, groupUsers.Results.Count);
}
public void WriteStorageIfNoneMatch()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INStorageKey> res = null;
var message = new NStorageWriteMessage.Builder()
.Write(Bucket, Collection, Record, StorageValue, IfNoneMatchVersion)
.Build();
client.Send(message, (INResultSet <INStorageKey> results) =>
{
res = results;
evt.Set();
}, _ => {
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNotNull(res);
Assert.IsNotEmpty(res.Results);
Assert.AreEqual(res.Results[0].Bucket, Bucket);
Assert.AreEqual(res.Results[0].Collection, Collection);
Assert.AreEqual(res.Results[0].Record, Record);
}
public void WritePublicStorage()
{
ManualResetEvent evt = new ManualResetEvent(false);
INResultSet <INStorageKey> res = null;
var message = new NStorageWriteMessage.Builder()
.Write(Bucket, Collection, Record, StorageValue, StoragePermissionRead.PublicRead, StoragePermissionWrite.OwnerWrite)
.Build();
client.Send(message, (INResultSet <INStorageKey> results) =>
{
res = results;
evt.Set();
}, _ => {
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNotNull(res);
Assert.IsNotEmpty(res.Results);
Assert.AreEqual(Bucket, res.Results[0].Bucket);
Assert.AreEqual(Collection, res.Results[0].Collection);
Assert.AreEqual(Record, res.Results[0].Record);
}
public void MessagesListTopic()
{
INError error = null;
ManualResetEvent evt1 = new ManualResetEvent(false);
string room = "history-room";
INTopic t = null;
client1.Send(new NTopicJoinMessage.Builder().TopicRoom(room).Build(), (INResultSet <INTopic> topics) =>
{
t = topics.Results[0];
evt1.Set();
}, (INError err) =>
{
error = err;
evt1.Set();
});
evt1.WaitOne(5000, false);
Assert.IsNull(error);
Assert.IsNotNull(t);
string data = "{\"some\":\"history data " +
System.Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(random.GetString())) + "\"}";
for (int i = 0; i < 10; i++)
{
ManualResetEvent evtFor = new ManualResetEvent(false);
client1.Send(NTopicMessageSendMessage.Default(t.Topic, data), (INTopicMessageAck ack) =>
{
evtFor.Set();
}, (INError err) =>
{
error = err;
evtFor.Set();
});
evtFor.WaitOne(5000, false);
if (error != null)
{
break;
}
}
Assert.IsNull(error);
INResultSet <INTopicMessage> messages = null;
ManualResetEvent evt2 = new ManualResetEvent(false);
client1.Send(new NTopicMessagesListMessage.Builder().TopicRoom(room).Forward(false).Limit(10).Build(), (INResultSet <INTopicMessage> msgs) =>
{
messages = msgs;
evt2.Set();
}, (INError err) =>
{
error = err;
evt2.Set();
});
evt2.WaitOne(5000, false);
Assert.IsNull(error);
Assert.IsNotNull(messages);
Assert.AreEqual(10, messages.Results.Count);
foreach (var msg in messages.Results)
{
Assert.AreEqual(data, msg.Data);
}
}
