public void RegisterSteam_Invalid([ValueSource("BlankCases")] string sessionToken)
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Steam(sessionToken);
client.Register(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("Steam registration not available", result.Message);
}
public void SetUp()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError error = null;
client = new NClient.Builder(DefaultServerKey).Build();
string id = TestContext.CurrentContext.Random.GetString();
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession authenticated) =>
{
session = authenticated;
client.Connect(session);
evt.Set();
}, (INError err) => {
error = err;
evt.Set();
});
evt.WaitOne(1000, false);
Assert.IsNull(error);
}
// +++ functions ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public INClient LoginOrRegister(string loginType, object userData)
{
_client = new NClient
.Builder(serverSettings.serverKey)
.Host(serverSettings.hostName)
.Port(serverSettings.port)
.SSL(serverSettings.ssl)
.Build();
// register a central point to handle events change the consistence of the
// players in the match
_client.OnMatchPresence += OnMatchPresence;
AuthenticatorFactory authenticatorFactory = new AuthenticatorFactory(_client);
ICustomAuthenticator authenticator = authenticatorFactory.GetAuthenticator(loginType);
authenticator.Login(
userData,
(INSession session) =>
{
_client.Connect(session, (bool done) =>
{
if (OnConnected != null)
{
OnConnected(session);
}
});
},
(INError error) =>
{
if (OnConnected != null)
{
OnConnected(null);
}
}
);
return(_client);
}
public void LoginDevice_Invalid_NoId()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
string id = random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("ID not found", result.Message);
}
public void RegisterDevice_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INSession result = null;
string id = TestContext.CurrentContext.Random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession session) =>
{
result = session;
evt.Set();
}, (INError error) =>
{
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.NotNull(result.Token);
}
public void GetServerTime_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
long serverTime = 0;
string id = TestContext.CurrentContext.Random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession session) =>
{
client.Connect(session);
Thread.Sleep(500);
serverTime = client.ServerTime;
evt.Set();
}, (INError _) => {
evt.Set();
});
evt.WaitOne(1000, false);
Assert.That(serverTime, Is.Not.EqualTo(0));
client.Disconnect();
}
public void LoginEmail_Invalid_Email()
{
ManualResetEvent evt = new ManualResetEvent(false);
INError result = null;
string email = random.GetString();
string password = random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Login(message, (INSession session) =>
{
evt.Set();
}, (INError error) =>
{
result = error;
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.AreEqual("Invalid email address format", result.Message);
}
public void Connect_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
var connected = false;
string id = TestContext.CurrentContext.Random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Device(id);
client.Register(message, (INSession session) =>
{
client.Connect(session, (bool _) => {
connected = true;
evt.Set();
});
}, (INError _) => {
evt.Set();
});
evt.WaitOne(500, false);
Assert.IsTrue(connected);
client.Disconnect();
}
public void SetUp()
{
INError error = null;
client1 = new NClient.Builder(DefaultServerKey).Build();
client2 = new NClient.Builder(DefaultServerKey).Build();
ManualResetEvent c1Evt = new ManualResetEvent(false);
client1.Register(NAuthenticateMessage.Device(random.GetString()), (INSession session) =>
{
userId1 = session.Id;
client1.Connect(session);
c1Evt.Set();
}, (INError err) =>
{
error = err;
c1Evt.Set();
});
c1Evt.WaitOne(5000, false);
Assert.IsNull(error);
ManualResetEvent c2Evt = new ManualResetEvent(false);
client2.Register(NAuthenticateMessage.Device(random.GetString()), (INSession session) =>
{
userId2 = session.Id;
client2.Connect(session);
c2Evt.Set();
}, (INError err) =>
{
error = err;
c2Evt.Set();
});
c2Evt.WaitOne(5000, false);
Assert.IsNull(error);
}
//Will join a room for the client, and update that room's userlist for all clients
public void JoinRoom(string roomName)
{
client = NakamaData.Singleton.Client;
ManualResetEvent joinEvent = new ManualResetEvent(false);
currentRoom = roomName;
var message = new NTopicJoinMessage.Builder().TopicRoom(Encoding.UTF8.GetBytes(roomName)).Build();
client.Send(message, (INTopic topic) =>
{
chatText.Add("Successfully joined the room '" + roomName + "'. There are currently " + topic.Presences.Count + " Users");
Debug.Log("Successfully Joined Room");
userList = topic.Presences;
currentTopic = topic.Topic;
joinEvent.Set();
}, (INError err) =>
{
Debug.Log("Failed to join room : " + err);
joinEvent.Set();
});
joinEvent.WaitOne(1000, false);
//Create the user list to display
foreach (var userInList in userList)
{
if (!chatUsersJoinedID.Contains(userInList.UserId))
{
chatUsersJoinedID.Add(userInList.UserId);
}
}
Debug.Log("JoinRoom:: ::chatUsersJoinedID.count: " + chatUsersJoinedID.Count);
UserListChange = true; //Run update to update UserList
RegisterOnTopicMessagePresence();
}
public void RegisterEmail_Valid()
{
ManualResetEvent evt = new ManualResetEvent(false);
INSession result = null;
string piece = random.GetString().Substring(8);
string email = String.Format("{0}@{0}.com", piece);
string password = TestContext.CurrentContext.Random.GetString();
INClient client = NClient.Default(DefaultServerKey);
var message = NAuthenticateMessage.Email(email, password);
client.Register(message, (INSession session) =>
{
result = session;
evt.Set();
}, (INError error) =>
{
evt.Set();
});
evt.WaitOne(500, false);
Assert.NotNull(result);
Assert.NotNull(result.Token);
}
public UnityMainThreadDispatch()
{
// A new Nakama client which uses a socket thread.
var client = new NClient.Builder(ServerKey)
.Host(ServerHost)
.Port(ServerPort)
.SSL(ServerSsl)
.Build();
// Wrap the socket client so we dispatch all callbacks on the main thread.
_client = new NManagedClient(client);
_uiLabelMessage = "Initial state.";
// Attach an error handler for received message errors.
_client.OnError = (INError error) => {
ErrorHandler(error);
};
// Log a message whenever we're disconnected from the server.
_client.OnDisconnect = (INDisconnectEvent evt) => {
Debug.Log("Disconnected from server.");
// We'll set a UI label from the socket.
_uiLabelMessage = "Disconnected.";
};
}
void Start()
{
RegisterButtonPlayer1 = GameObject.Find("RegisterButtonPlayer1").GetComponent <Button>();
LoginButtonPlayer1 = GameObject.Find("LoginButtonPlayer1").GetComponent <Button>();
ConnectPlayer1 = GameObject.Find("ConnectPlayer1").GetComponent <Button>();
RegisterButtonPlayer2 = GameObject.Find("RegisterButtonPlayer2").GetComponent <Button>();
LoginButtonPlayer2 = GameObject.Find("LoginButtonPlayer2").GetComponent <Button>();
ConnectPlayer2 = GameObject.Find("ConnectPlayer2").GetComponent <Button>();
SelfPlayer1 = GameObject.Find("SelfPlayer1").GetComponent <Button>();
SelfPlayer2 = GameObject.Find("SelfPlayer2").GetComponent <Button>();
JoinTopicPlayer1 = GameObject.Find("JoinTopicPlayer1").GetComponent <Button>();
JoinTopicPlayer2 = GameObject.Find("JoinTopicPlayer2").GetComponent <Button>();
SendChatPlayer1 = GameObject.Find("SendChatPlayer1").GetComponent <Button>();
SendChatPlayer2 = GameObject.Find("SendChatPlayer2").GetComponent <Button>();
OutputTextField = GameObject.Find("OutputTextField").GetComponent <Text>();
client1 = new NClient.Builder("defaultkey")
.Host("127.0.0.1")
.Port(7350)
.SSL(false)
.Build();
client2 = new NClient.Builder("defaultkey")
.Host("127.0.0.1")
.Port(7350)
.SSL(false)
.Build();
client1.OnTopicMessage += (object sender, NTopicMessageEventArgs e) => {
outputText = Encoding.UTF8.GetString(e.Message.Data);
};
client2.OnTopicMessage += (object sender, NTopicMessageEventArgs e) => {
outputText = Encoding.UTF8.GetString(e.Message.Data);
};
}
// +++ constructor ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public AuthenticatorFactory(INClient client)
{
_client = client;
}
void Start()
{
RegisterButtonPlayer1 = GameObject.Find("RegisterButtonPlayer1").GetComponent <Button>();
LoginButtonPlayer1 = GameObject.Find("LoginButtonPlayer1").GetComponent <Button>();
ConnectPlayer1 = GameObject.Find("ConnectPlayer1").GetComponent <Button>();
RegisterButtonPlayer2 = GameObject.Find("RegisterButtonPlayer2").GetComponent <Button>();
LoginButtonPlayer2 = GameObject.Find("LoginButtonPlayer2").GetComponent <Button>();
ConnectPlayer2 = GameObject.Find("ConnectPlayer2").GetComponent <Button>();
JoinTopicPlayer1 = GameObject.Find("JoinTopicPlayer1").GetComponent <Button>();
JoinTopicPlayer2 = GameObject.Find("JoinTopicPlayer2").GetComponent <Button>();
SendChatPlayer1 = GameObject.Find("SendChatPlayer1").GetComponent <Button>();
SendChatPlayer2 = GameObject.Find("SendChatPlayer2").GetComponent <Button>();
OutputTextField = GameObject.Find("OutputTextField").GetComponent <Text>();
client1 = new NClient.Builder("defaultkey")
.Host("127.0.0.1")
.Port(7350)
.SSL(false)
.Build();
client2 = new NClient.Builder("defaultkey")
.Host("127.0.0.1")
.Port(7350)
.SSL(false)
.Build();
client1.OnTopicMessage = (INTopicMessage message) => {
outputText = message.Data;
};
client1.OnTopicPresence = (INTopicPresence presences) => {
foreach (var presence in presences.Join)
{
Debug.LogFormat("Presence update received by Player 1: User handle '{0}' joined the topic.", presence.Handle);
}
foreach (var presence in presences.Leave)
{
Debug.LogFormat("Presence update received by Player 1: User handle '{0}' left the topic.", presence.Handle);
}
};
client2.OnTopicMessage = (INTopicMessage message) => {
outputText = message.Data;
};
client2.OnTopicPresence = (INTopicPresence presences) => {
foreach (var presence in presences.Join)
{
Debug.LogFormat("Presence update received by Player 2: User handle '{0}' joined the topic.", presence.Handle);
}
foreach (var presence in presences.Leave)
{
Debug.LogFormat("Presence update received by Player 2: User handle '{0}' left the topic.", presence.Handle);
}
};
// Add button handlers
RegisterButtonPlayer1.onClick.AddListener(Player1RegisterClick);
LoginButtonPlayer1.onClick.AddListener(Player1LoginClick);
ConnectPlayer1.onClick.AddListener(Player1Connect);
RegisterButtonPlayer2.onClick.AddListener(Player2RegisterClick);
LoginButtonPlayer2.onClick.AddListener(Player2LoginClick);
ConnectPlayer2.onClick.AddListener(Player2Connect);
JoinTopicPlayer1.onClick.AddListener(Player1JoinTopic);
JoinTopicPlayer2.onClick.AddListener(Player2JoinTopic);
SendChatPlayer1.onClick.AddListener(Player1SendChatMessage);
SendChatPlayer2.onClick.AddListener(Player2SendChatMessage);
}
// +++ constructor ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public NvpDeviceIdLoginOrRegisterAuthenticator(INClient client)
{
_client = client;
}
public void UnRegisterOnMatchData()
{
client = NakamaData.Singleton.Client;
client.OnMatchData -= c_OnMatchData;
client.OnMatchPresence -= c_OnMatchPresence;
}
public void UnRegisterMatchListRoom()
{
client = NakamaData.Singleton.Client;
//client.OnTopicMessage -= MatchList_OnTopicMessage;
}
// +++ constructor ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public NvpRandomGuidLoginOrRegisterAuthenticator(INClient client)
{
_client = client;
}
// +++ Unity callbacks ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void Awake()
{
client = InstantiateNetworkClient(serverKey, url, port, ssl);
}
private void GetPreviousMatchesFromRoom()
{
ManualResetEvent historyEvent = new ManualResetEvent(false);
client = NakamaData.Singleton.Client;
byte[] roomByte = Encoding.UTF8.GetBytes("match-list");
IList <INTopicMessage> msgsReturned = null;
var message = new NTopicMessagesListMessage.Builder()
.TopicRoom(roomByte)
.Forward(false)
.Limit(100)
.Build();
client.Send(message, (INResultSet <INTopicMessage> msgs) =>
{
// Each message in the result set is a `INTopicMessage` identical
// to messages received through `OnTopicMessage` realtime delivery.
msgsReturned = msgs.Results;
Debug.Log("Successfully listed messages from topic. msgs.Results.Count: " + msgs.Results.Count + " msgsReturned.Count: " + msgsReturned.Count);
historyEvent.Set();
}, (INError error) => {
Debug.LogErrorFormat("Could not list messages from topic: '{0}'.", error.Message);
historyEvent.Set();
});
historyEvent.WaitOne(1000, false);
if (msgsReturned.Count < 1)
{
return;
}
//GO through the messages as if they were just recieved
foreach (INTopicMessage topicMessage in msgsReturned)
{
Debug.Log("topicMessage.Data.ToString(): " + topicMessage.Data.ToString());
var bytesAsString = Encoding.ASCII.GetString(topicMessage.Data);
var chatJson = JsonUtility.FromJson <MatchRoomClass>(bytesAsString);
Guid tempMatchID = new Guid(chatJson.matchIDGUID);
MatchSettings newSettings = new MatchSettings();
newSettings.matchCreator = chatJson.userName;
newSettings.maxHealth = chatJson.matchMaxHealth;
newSettings.matchName = chatJson.matchName;
if (chatJson.addRemove == "add")
{
Debug.Log("Adding previous match: " + chatJson.matchName);
newSettings.matchStatus = "open";
//matchNameMatchGuid.Add(chatJson.matchName, tempMatchID.ToByteArray());
if (matchGuidMatchSettings.ContainsKey(tempMatchID))
{
return;
}
matchGuidMatchSettings.Add(tempMatchID, newSettings);
Debug.Log("Added matchGuidMatchSettings.Count: " + matchGuidMatchSettings.Count); //match matchNameMatchGuid.Count: " + matchNameMatchGuid.Count + " matchGuidMatchSettings.Count: " + matchGuidMatchSettings.Count);
}
else
{
Debug.Log("Removing matchGuidMatchSettings.Count: " + matchGuidMatchSettings.Count); //match matchNameMatchGuid.Count: " + matchNameMatchGuid.Count + " matchGuidMatchSettings.Count: " + matchGuidMatchSettings.Count);
//matchNameMatchGuid.Remove(chatJson.matchName);
//matchGuidMatchSettings.Remove(chatJson.matchName);
if (matchGuidMatchSettings.ContainsKey(tempMatchID))
{
matchGuidMatchSettings[tempMatchID].matchStatus = "closed";
}
else
{
newSettings.matchStatus = "closed";
matchGuidMatchSettings.Add(tempMatchID, newSettings); //Only reason we add, is so if it comes up again in message
}
Debug.Log("Removed matchGuidMatchSettings.Count: " + matchGuidMatchSettings.Count); //match matchNameMatchGuid.Count: " + matchNameMatchGuid.Count + " matchGuidMatchSettings.Count: " + matchGuidMatchSettings.Count);
}
}
}
