public void AuthentificationFailedForSecondConnection()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
var authentificationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
var connection1 = new Mock <IConnection>();
var client1 = new ChatClient(connection1.Object, manager);
connection1.Raise(c => c.PacketReceived += null, connection1.Object, authentificationPacket);
var connection2 = new Mock <IConnection>();
var disconnectedRaised = false;
var client2 = new ChatClient(connection2.Object, manager);
client2.Disconnected += (sender, e) => disconnectedRaised = true;
connection2.Setup(c => c.Disconnect()).Verifiable();
connection2.Raise(c => c.PacketReceived += null, connection2.Object, authentificationPacket);
Assert.That(room.ConnectedClients, Has.Count.EqualTo(1));
Assert.That(room.ConnectedClients, Contains.Item(client1));
connection2.VerifyAll();
Assert.That(disconnectedRaised, Is.True);
}
public JoinRoomIncomingMessage(ChatRoomManager chatRoomManager, MatchListingManager matchListingManager, MatchManager matchManager)
{
this.chatRoomManager = chatRoomManager;
this.matchListingManager = matchListingManager;
this.matchManager = matchManager;
}
public async Task AuthenticationFailedForSecondConnection()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
var authenticationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
var duplexPipe1 = new DuplexPipe();
var connection1 = new Connection(duplexPipe1, null, null);
var client1 = new ChatClient(connection1, manager);
await duplexPipe1.ReceivePipe.Writer.WriteAsync(authenticationPacket);
await duplexPipe1.ReceivePipe.Writer.FlushAsync();
var duplexPipe2 = new DuplexPipe();
var connection2 = new Connection(duplexPipe2, null, null);
var client2 = new ChatClient(connection2, manager);
bool disconnectedRaised = false;
client2.Disconnected += (sender, e) => disconnectedRaised = true;
await duplexPipe2.ReceivePipe.Writer.WriteAsync(authenticationPacket);
await duplexPipe2.ReceivePipe.Writer.FlushAsync();
Assert.That(room.ConnectedClients, Has.Count.EqualTo(1));
Assert.That(room.ConnectedClients, Contains.Item(client1));
Assert.That(connection2.Connected, Is.False);
Assert.That(disconnectedRaised, Is.True);
}
public void ClientLoggedOff()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var connection1 = new Mock <IConnection>();
var client1 = new ChatClient(connection1.Object, manager);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Alice", "94371960"));
var authentificationPacket1 = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
connection1.Raise(c => c.PacketReceived += null, connection1.Object, authentificationPacket1);
var connection2 = new Mock <IConnection>();
var client2 = new ChatClient(connection2.Object, manager);
var authentificationPacket2 = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xC5, 0xFB, 0x98, 0xCB, 0xFE, 0x92, 0xCA, 0xFF, 0xAB, 0xFC };
connection2.Raise(c => c.PacketReceived += null, connection2.Object, authentificationPacket2);
client1.LogOff();
var expectedPacket = new byte[]
{
0xC1, 0x0F, 0x01, 0x01, 0x00, 0x42, 0x6F, 0x62, 0, 0, 0, 0, 0, 0, 0,
};
connection2.Verify(c => c.Send(It.Is <byte[]>(p => p.SequenceEqual(expectedPacket))), Times.Once);
Assert.That(room.ConnectedClients, Has.Count.EqualTo(1));
Assert.That(room.ConnectedClients, Contains.Item(client2));
}
public void ClientLoggedOff()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var connection1 = MockRepository.GenerateMock <IConnection>();
var client1 = new ChatClient(connection1, manager);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Alice", "94371960"));
var authentificationPacket1 = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
connection1.Raise(c => c.PacketReceived += null, connection1, authentificationPacket1);
var connection2 = MockRepository.GenerateMock <IConnection>();
var client2 = new ChatClient(connection2, manager);
var authentificationPacket2 = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xC5, 0xFB, 0x98, 0xCB, 0xFE, 0x92, 0xCA, 0xFF, 0xAB, 0xFC };
connection2.Raise(c => c.PacketReceived += null, connection2, authentificationPacket2);
client1.LogOff();
var arguments = connection2.GetArgumentsForCallsMadeOn(c => c.Send(null));
var sentPacket = arguments.FirstOrDefault(p => (p.Last() as byte[])[0] == 0xC1)[0] as byte[];
var expectedPacket = new byte[]
{
0xC1, 0x0F, 0x01, 0x01, 0x00, 0x42, 0x6F, 0x62, 0, 0, 0, 0, 0, 0, 0,
};
Assert.That(room.ConnectedClients, Has.Count.EqualTo(1));
Assert.That(room.ConnectedClients, Contains.Item(client2));
Assert.That(sentPacket, Is.Not.Null);
Assert.That(sentPacket, Is.EquivalentTo(expectedPacket));
}
public void AddMessageToChatRoomAddsMessage()
{
// Arrange
ChatRoom parameter = null;
var chatRoomRepositoryMock = new Mock <IRepository <ChatRoom, long> >(MockBehavior.Strict);
chatRoomRepositoryMock.Setup(repository => repository.FindByIdWithMessages(It.IsAny <long>())).Returns(new List <ChatRoom>()
{
new ChatRoom("room")
});
chatRoomRepositoryMock.Setup(repository => repository.Exists(It.IsAny <long>())).Returns(true);
chatRoomRepositoryMock.Setup(repository => repository.Update(It.IsAny <ChatRoom>()))
.Callback <ChatRoom>((chatRoom) => parameter = chatRoom);
ChatRoomManager chatRoomManager = new ChatRoomManager(chatRoomRepositoryMock.Object);
long chatRoomId = 1;
Message message = new Message("Carla Red", "Hello World");
// Act Assert
chatRoomManager.AddMessageToChatRoom(chatRoomId, message);
// Assert
Assert.AreEqual(1, parameter.Messages.Count);
Assert.AreEqual("Carla Red", parameter.Messages[0].Sender);
Assert.AreEqual("Hello World", parameter.Messages[0].Content);
Assert.AreEqual("room", parameter.Name);
}
public void GetChatRoomNull()
{
var manager = new ChatRoomManager(new NullLoggerFactory());
var room = manager.GetChatRoom(9999);
Assert.That(room, Is.Null);
}
public void GetChatRoomNull()
{
var manager = new ChatRoomManager();
var room = manager.GetChatRoom(9999);
Assert.That(room, Is.Null);
}
public void RoomCreation()
{
var manager = new ChatRoomManager(new NullLoggerFactory());
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
Assert.That(room, Is.Not.Null);
}
public void RoomCreationUniqueIds()
{
var manager = new ChatRoomManager(new NullLoggerFactory());
var roomId1 = manager.CreateChatRoom();
var roomId2 = manager.CreateChatRoom();
Assert.That(roomId1, Is.Not.EqualTo(roomId2));
}
private void initManagers()
{
_registrationManager = instantiateManager <RegistrationManager>(_registrationManagerPFB);
_chatLobbyManager = instantiateManager <ChatLobbyManager>(_chatLobbyManagerPFB);
_popupManager = instantiateManager <PopupManager>(_popupManagerPFB);
_sceneSelectionManager = instantiateManager <SceneSelectionManager>(_sceneSelectionManagerPFB);
_characterSelectionManager = instantiateManager <SceneCharacterSelectionManager>(_characterSelectionManagerPFB);
_chatRoomManager = instantiateManager <ChatRoomManager>(_chatRoomManagerPFB);
}
private void Initialize()
{
connections = new Connections();
manager = new ChatRoomManager(connections);
connections.AdminConnectRoomHandler = manager.AdminRoomConnection;
listener = new TcpListener(IPAddress.Parse("127.0.0.1"), Port);
threadListener = new Thread(new ThreadStart(ListenLoop));
threadListener.Name = "Connection Thread";
threadListener.Start();
}
public PacketManager(ServerManager serverManager, ClientManager clientManager, ChatRoomManager chatRoomManager, MatchListingManager matchListingManager, MatchManager matchManager, ILoggerFactory loggerFactory)
{
this.IncomingPacketsJSON = new Dictionary <Type, IMessageIncomingJson>()
{
{ typeof(JsonConfirmConnectionIncomingMessage), new ConfirmConnectionIncomingMessage() },
{ typeof(JsonTokenLoginIncomingMessage), new TokenLoginIncomingMessage(serverManager, clientManager, loggerFactory.CreateLogger <TokenLoginIncomingMessage>()) },
{ typeof(JsonGuestLoginIncomingPacket), new GuestLoginIncomingMessage(serverManager, clientManager, loggerFactory.CreateLogger <GuestLoginIncomingMessage>()) },
{ typeof(JsonLegacyPingIncomingMessage), new LegacyPingIncomingMessage() },
{ typeof(JsonManageVarsIncomingMessage), new ManageVarsIncomingMessage() },
{ typeof(JsonSetAccountSettingsMessage), new SetAccountSettingsIncomingMessage() },
{ typeof(JsonGetLevelListIncomingMessage), new GetLevelListIncomingMessage() },
{ typeof(JsonJoinRoomIncomingMessage), new JoinRoomIncomingMessage(chatRoomManager, matchListingManager, matchManager) },
{ typeof(JsonGetLevelOfTheDayIncomingMessage), new GetLevelOfTheDayIncomingMessage(matchListingManager) },
{ typeof(JsonGetTournamentIncomingMessage), new GetTournamentIncomingMessage(matchListingManager, matchManager) },
{ typeof(JsonRequestMatchesIncomingMessage), new RequestMatchesIncominggMessage(matchListingManager) },
{ typeof(JsonGetRoomsIncomingMessage), new GetRoomsIncomingMessage(chatRoomManager) },
{ typeof(JsonLeaveRoomIncomingMessage), new LeaveRoomIncomingMessage(chatRoomManager, matchListingManager, matchManager) },
{ typeof(JsonLeaveLobbyIncomingMessage), new LeaveLobbyIncomingMessage() },
{ typeof(JsonGetMemberListIncomingMessage), new GetMemberListIncomingMessage(chatRoomManager) },
{ typeof(JsonGetUserListIncomingMessage), new GetUserListIncomingMessage(clientManager) },
{ typeof(JsonGetUserPageIncomingMessage), new GetUserPageIncomingMessage(clientManager) },
{ typeof(JsonSendToRoomIncomingMessage), new SendToRoomIncomingMessage(chatRoomManager) },
{ typeof(JsonCreateMatchIncomingMessage), new CreateMatchIncomingMessage(matchListingManager) },
{ typeof(JsonForceStartIncomingMessage), new ForceStartIncomingMessage() },
{ typeof(JsonFinishDrawingIncomingMessage), new FinishDrawingIncomingMessage() },
{ typeof(JsonForfietIncomingMessage), new ForfietIncomingMessage() },
{ typeof(JsonFinishMatchIncomingMessage), new FinishMatchIncomingMessage() },
{ typeof(JsonLoseHatIncomingMessage), new LoseHatIncomingMessage() },
{ typeof(JsonGetHatIncomingMessage), new GetHatIncomingMessage() },
{ typeof(JsonCoinsIncomingMessage), new CoinsIncomingMessage() },
{ typeof(JsonGetPmsIncomingMessage), new GetPmsIncomingMessage() },
{ typeof(JsonGetPmIncomingMessage), new GetPmIncomingMessage() },
{ typeof(JsonDeletePmsIncomingMessage), new DeletePmsIncomingMessage() },
{ typeof(JsonSendPmIncomingMessage), new SendPmIncomingMessage() },
{ typeof(JsonEditUserListIncomingMessage), new EditUserListIncomingMessage() },
{ typeof(JsonKickFromMatchListingIncomingMessage), new KickFromMatchListingIncomingMessage() },
{ typeof(JsonBanFromMatchListingIncomingMessage), new BanFromMatchListingIncomingMessage() },
{ typeof(JsonStartQucikJoinIncomingMessage), new StartQucikJoinIncomingMessage(matchListingManager) },
{ typeof(JsonStopQuickJoinIncomingMessage), new StopQuickJoinIncomingMessage(matchListingManager) },
{ typeof(JsonRateLevelIncomingMessage), new RateLevelIncomingMessage() },
{ typeof(JsonSendThingIncomingMessage), new SendThingIncomingMessage() },
{ typeof(JsonThingExistsIncomingMessage), new ThingExistsIncomingMessage() },
{ typeof(JsonAcceptThingTransferIncomingMessage), new AcceptThingTransferIncomingMessage() },
{ typeof(JsonReportPmIncomingMessage), new ReportPmIncomingMessage() },
{ typeof(JsonKothIncomingMessage), new KothIncomingMessage() },
{ typeof(JsonDashIncomingMessage), new DashIncomingMessage() },
{ typeof(JsonJoinTournamentIncomingMessage), new JoinTournamentIncomingMessage(matchListingManager, matchManager) },
{ typeof(JsonWinHatIncomingMessage), new WinHatIncomingMessage() },
};
}
public void GetAllChatRoomsCallsRepository()
{
// Arrange
var chatRoomRepositoryMock = new Mock <IRepository <ChatRoom, long> >(MockBehavior.Strict);
chatRoomRepositoryMock.Setup(repository => repository.FindAll()).Returns(new List <ChatRoom>());
ChatRoomManager chatRoomManager = new ChatRoomManager(chatRoomRepositoryMock.Object);
// Act
var result = chatRoomManager.GetAllChatRooms();
// Assert
chatRoomRepositoryMock.Verify(repository => repository.FindAll(), Times.Once);
}
public void SetNickname()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var connection = MockRepository.GenerateMock <IConnection>();
var client = new ChatClient(connection, manager);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
var authentificationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
connection.Raise(c => c.PacketReceived += null, connection, authentificationPacket);
Assert.That(client.Nickname, Is.EqualTo("Bob"));
}
public void GetAllChatRoomsReturnsIEnumerableChatRoom()
{
// Arrange
var chatRoomRepositoryMock = new Mock <IRepository <ChatRoom, long> >(MockBehavior.Strict);
chatRoomRepositoryMock.Setup(repository => repository.FindAll()).Returns(new List <ChatRoom>());
ChatRoomManager chatRoomManager = new ChatRoomManager(chatRoomRepositoryMock.Object);
// Act
var result = chatRoomManager.GetAllChatRooms();
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IEnumerable <ChatRoom>));
}
public async Task RoomChatShowsOnlyFiftyMessages()
{
var chatRooms = this.GetChatRooms();
var chatRoomRepositoryMock = new Mock <IRepository <ChatRoom> >();
var userRepositoryMock = new Mock <IRepository <ApplicationUser> >();
chatRoomRepositoryMock.Setup(x => x.All()).Returns(chatRooms.AsQueryable());
chatRoomRepositoryMock.Setup(x => x.FindAsync(It.IsAny <object[]>()))
.Returns((object[] name) => Task.FromResult(chatRooms.FirstOrDefault(c => c.Name == name.First().ToString())));
var chatRoomManager = new ChatRoomManager(chatRoomRepositoryMock.Object, userRepositoryMock.Object);
var messages = await chatRoomManager.GetMessagesAsync("Default Room");
Assert.IsTrue(messages.Count() <= 50);
}
public void AuthentificationSuccess()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var connection = new Mock <IConnection>();
var client = new ChatClient(connection.Object, manager);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
var authentificationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
connection.Raise(c => c.PacketReceived += null, connection.Object, authentificationPacket);
Assert.That(room.ConnectedClients, Contains.Item(client));
}
public async Task SentMessageEncryptedProperly()
{
var manager = new ChatRoomManager(new NullLoggerFactory());
var duplexPipe = new DuplexPipe();
var connection = new Connection(duplexPipe, null, null, new NullLogger <Connection>());
var client = new ChatClient(connection, manager, new NullLogger <ChatClient>());
var expectedPacket = new byte[] { 0xC1, 0x0B, 0x04, 0x01, 0x06, 0xBD, 0x8E, 0xEA, 0xBD, 0x8E, 0xEA };
client.SendMessage(1, "AAAAAA");
var sendResult = await duplexPipe.SendPipe.Reader.ReadAsync();
var sentPacket = sendResult.Buffer.ToArray();
Assert.That(expectedPacket, Is.EqualTo(sentPacket));
}
public SteamNerd()
{
SteamClient = new SteamClient();
CallbackManager = new CallbackManager(SteamClient);
ModuleManager = new ModuleManager(this);
UserManager = new UserManager(this, "admins.txt");
ChatRoomManager = new ChatRoomManager(this, "chats.txt");
SteamUser = SteamClient.GetHandler <SteamUser>();
SteamFriends = SteamClient.GetHandler <SteamFriends>();
SubscribeCallbacks();
_login = new Login(this, CallbackManager);
}
public void AddChatRoomCallsRepository()
{
// Arrange
var chatRoomRepositoryMock = new Mock <IRepository <ChatRoom, long> >(MockBehavior.Strict);
chatRoomRepositoryMock.Setup(repository => repository.Insert(It.IsAny <ChatRoom>())).Returns(1);
ChatRoomManager chatRoomManager = new ChatRoomManager(chatRoomRepositoryMock.Object);
ChatRoom chatRoom = new ChatRoom("room");
// Act
chatRoomManager.AddChatRoom(chatRoom);
// Assert
chatRoomRepositoryMock.Verify(repository => repository.Insert(It.IsAny <ChatRoom>()), Times.Once);
}
internal ChatRoom(ChatRoomManager chatRoomManager, CommandManager commandManager, ChatRoomType type, uint creatorUserId, string name, string pass, string note)
{
this.chatRoomManager = chatRoomManager;
this.commandManager = commandManager;
this.Clients = new ClientSessionCollection(removeCallback: this.Leave0);
this.BannedClients = new ConcurrentBag <IUserIdentifier>();
this.RecentMessages = new ConcurrentQueue <ChatOutgoingMessage>();
this.CreatorUserId = creatorUserId;
this.Type = type;
this.Name = name;
this.Pass = pass;
this.Note = note;
}
public void SetClientIndex()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var connection = new Mock <IConnection>();
var client = new ChatClient(connection.Object, manager);
var authInfo = new ChatServerAuthenticationInfo(3, roomId, "Bob", "128450673");
room.RegisterClient(authInfo);
var authentificationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
connection.Raise(c => c.PacketReceived += null, connection.Object, authentificationPacket);
Assert.That(client.Index, Is.EqualTo(authInfo.Index));
}
public void FindChatRoomByIdWithInvalidIdThrowsKeyNotFoundException()
{
// Arrange
var chatRoomRepositoryMock = new Mock <IRepository <ChatRoom, long> >(MockBehavior.Strict);
chatRoomRepositoryMock.Setup(repository => repository.Exists(It.IsAny <long>())).Returns(false);
chatRoomRepositoryMock.Setup(repository => repository.FindByIdWithMessages(It.IsAny <long>())).Returns(new List <ChatRoom>()
{
new ChatRoom("room")
});
ChatRoomManager chatRoomManager = new ChatRoomManager(chatRoomRepositoryMock.Object);
long chatRoomId = 1;
// Act Assert
Assert.ThrowsException <KeyNotFoundException>(() => chatRoomManager.FindChatRoomById(chatRoomId));
}
public async Task SetNickname()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var duplexPipe = new DuplexPipe();
var connection = new Connection(duplexPipe, null, null);
var client = new ChatClient(connection, manager);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
var authenticationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
await duplexPipe.ReceivePipe.Writer.WriteAsync(authenticationPacket);
await duplexPipe.ReceivePipe.Writer.FlushAsync();
Assert.That(client.Nickname, Is.EqualTo("Bob"));
}
public void AuthentificationFailedByWrongToken()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var connection = MockRepository.GenerateMock <IConnection>();
var client = new ChatClient(connection, manager);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450674"));
connection.Expect(c => c.Disconnect());
var authentificationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
connection.Raise(c => c.PacketReceived += null, connection, authentificationPacket);
Assert.That(room.ConnectedClients.Contains(client), Is.False);
connection.VerifyAllExpectations();
}
public async Task AuthenticationFailedByWrongToken()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var duplexPipe = new DuplexPipe();
var connection = new Connection(duplexPipe, null, null);
var client = new ChatClient(connection, manager);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450674"));
var authenticationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
await duplexPipe.ReceivePipe.Writer.WriteAsync(authenticationPacket);
await duplexPipe.ReceivePipe.Writer.FlushAsync();
Assert.That(room.ConnectedClients.Contains(client), Is.False);
Assert.That(connection.Connected, Is.False);
}
public async Task AuthenticationSuccess()
{
var manager = new ChatRoomManager(new NullLoggerFactory());
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var duplexPipe = new DuplexPipe();
var connection = new Connection(duplexPipe, null, null, new NullLogger <Connection>());
var client = new ChatClient(connection, manager, new NullLogger <ChatClient>());
room !.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
var authenticationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
await duplexPipe.ReceivePipe.Writer.WriteAsync(authenticationPacket);
await duplexPipe.ReceivePipe.Writer.FlushAsync();
Assert.That(room.ConnectedClients, Contains.Item(client));
}
public void RoomClientListSentAfterJoin()
{
var manager = new ChatRoomManager();
var roomId = manager.CreateChatRoom();
var room = manager.GetChatRoom(roomId);
var connection = new Mock <IConnection>();
var client = new ChatClient(connection.Object, manager);
room.RegisterClient(new ChatServerAuthenticationInfo(room.GetNextClientIndex(), roomId, "Bob", "128450673"));
var authentificationPacket = new byte[] { 0xC1, 0x10, 0x00, 0x00, (byte)roomId, (byte)(roomId >> 8), 0xCD, 0xFD, 0x93, 0xC8, 0xFA, 0x9B, 0xCA, 0xF8, 0x98, 0xFC };
connection.Raise(c => c.PacketReceived += null, connection.Object, authentificationPacket);
var expectedPacket = new byte[] { 0xC2, 0x00, 0x13, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x42, 0x6F, 0x62, 0, 0, 0, 0, 0, 0, 0 };
connection.Verify(c => c.Send(It.Is <byte[]>(arg => arg.SequenceEqual(expectedPacket))), Times.Once);
Assert.That(client.Nickname, Is.EqualTo("Bob"));
}
public void AddMessageToChatRoomWithInvalidIdThrowsKeyNotFoundException()
{
// Arrange
var chatRoomRepositoryMock = new Mock <IRepository <ChatRoom, long> >(MockBehavior.Strict);
chatRoomRepositoryMock.Setup(repository => repository.FindByIdWithMessages(It.IsAny <long>())).Returns(new List <ChatRoom>()
{
new ChatRoom("room")
});
chatRoomRepositoryMock.Setup(repository => repository.Exists(It.IsAny <long>())).Returns(false);
chatRoomRepositoryMock.Setup(repository => repository.Update(It.IsAny <ChatRoom>()));
ChatRoomManager chatRoomManager = new ChatRoomManager(chatRoomRepositoryMock.Object);
long chatRoomId = 1;
Message message = new Message("Carla Red", "Hello World");
// Act Assert
Assert.ThrowsException <KeyNotFoundException>(() => chatRoomManager.AddMessageToChatRoom(chatRoomId, message));
}
/// <summary>
/// Create a new OSCAR session
/// </summary>
/// <param name="screenname">The screenname to log in</param>
/// <param name="password">The password associated with the screenname</param>
/// <exception cref="ArgumentException">Thrown when <paramref name="screenname"/> is not
/// a valid AIM or ICQ screenname.</exception>
public Session(string screenname, string password)
{
// Check to make sure the screenname is something valid
if (!ScreennameVerifier.IsValidAIM(screenname) &&
!ScreennameVerifier.IsValidICQ(screenname))
{
throw new ArgumentException(screenname + " is not a valid AIM or ICQ screenname", "screenname");
}
// Save parameter values
_screenname = screenname;
_password = password;
connectionManager = new ConnectionManager(this);
serviceManager = new ServiceManager(this);
ssiManager = new SSIManager(this);
icqManager = new IcqManager(this);
messageManager = new MessageManager(this);
statusManager = new StatusManager(this);
chatRoomManager = new ChatRoomManager(this);
graphicsManager = new GraphicsManager(this);
authManager = new AuthorizationManager(this);
searchManager = new SearchManager(this);
rateManager = new RateClassManager(this);
statsManager = new UsageStatsManager(this);
connectionManager.CreateNewConnection(0x0017);
// Create a default set of capabilities for this session
SetDefaultIdentification();
// Set up some default values for public properties
_publicidletime = true;
// Set initial values for internal properties
_loggedin = false;
_privacy = PrivacySetting.AllowAllUsers;
_parametercount = 0;
}
