Esempio n. 1
0
        public static List <string> WaitForPackets(FakeNetworkClient client, string lastPacketHeader, int timeout = 5)
        {
            DateTime      startTime = DateTime.Now;
            List <string> packets   = new List <string>();

            while (true)
            {
                if (client.SentPackets.Count > 0)
                {
                    string packet = client.SentPackets.Dequeue();
                    if (packet != null)
                    {
                        packets.Add(packet);
                        if (packet.StartsWith(lastPacketHeader))
                        {
                            return(packets);
                        }
                    }
                }

                if (startTime.AddSeconds(timeout) <= DateTime.Now)
                {
                    return(packets); // timing out
                }
            }
        }
Esempio n. 2
0
        public static List <string> WaitForPackets(FakeNetworkClient client, int amount)
        {
            DateTime startTime = DateTime.Now;

            int           receivedPackets = 0;
            List <string> packets         = new List <string>();

            while (receivedPackets < amount)
            {
                if (client.SentPackets.Count > 0)
                {
                    packets.Add(client.SentPackets.Dequeue());
                    receivedPackets++;
                }

                // exit token
                if (startTime.AddSeconds(10) < DateTime.Now)
                {
                    Assert.Fail($"Timed out while waiting for {amount} Packets");
                    return(new List <string>());
                }
            }

            return(packets);
        }
        public void GroupTest()
        {
            // login, create character, start game
            FakeNetworkClient clientA = HandlerTestHelper.InitializeTestEnvironment();
            FakeNetworkClient clientB = HandlerTestHelper.CreateFakeNetworkClient();

            Thread.Sleep(1000);

            // client A asks client B for group
            PJoinPacket pjoinPacketRequest = new PJoinPacket()
            {
                CharacterId = clientB.Session.Character.CharacterId,
                RequestType = GroupRequestType.Invited
            };

            clientA.ReceivePacket(pjoinPacketRequest);
            HandlerTestHelper.WaitForPackets(clientA, 1);

            // client B accepts group request
            PJoinPacket pjoinPacketAccept = new PJoinPacket()
            {
                CharacterId = clientA.Session.Character.CharacterId,
                RequestType = GroupRequestType.Accepted
            };

            clientB.ReceivePacket(pjoinPacketAccept);
            HandlerTestHelper.WaitForPackets(clientA, 1);

            // check if group has been created successfully
            Assert.IsNotNull(clientA.Session.Character.Group);
            Assert.IsNotNull(clientB.Session.Character.Group);
            Assert.AreEqual(2, clientA.Session.Character.Group.CharacterCount);
        }
Esempio n. 4
0
        public void SessionManagerTest()
        {
            System.Globalization.CultureInfo.DefaultThreadCurrentUICulture = System.Globalization.CultureInfo.GetCultureInfo("en-US");

            //initialize Logger
            Logger.InitializeLogger(LogManager.GetLogger(typeof(CoreTest)));

            //initialilize maps
            ServerManager.Initialize();

            //register mappings for items
            DAOFactory.InventoryDAO.RegisterMapping(typeof(SpecialistInstance));
            DAOFactory.InventoryDAO.RegisterMapping(typeof(WearableInstance));
            DAOFactory.InventoryDAO.RegisterMapping(typeof(UsableInstance));
            DAOFactory.InventoryDAO.InitializeMapper(typeof(ItemInstance));

            //initialize PacketSerialization
            PacketFactory.Initialize <WalkPacket>();

            //initialize new manager
            SessionManager    manager = new SessionManager(typeof(CharacterScreenPacketHandler), true);
            FakeNetworkClient client  = new FakeNetworkClient();

            manager.AddSession(client);
        }
        // [Test]
        public void InitializeTestEnvironmentTest()
        {
            // login, create character, start game
            FakeNetworkClient client = HandlerTestHelper.InitializeTestEnvironment();

            HandlerTestHelper.ShutdownTestingEnvironment();
            Assert.Pass();
        }
Esempio n. 6
0
 public static string WaitForPacket(FakeNetworkClient client)
 {
     while (true)
     {
         if (client.SentPackets.Count > 0)
         {
             return(client.SentPackets.Dequeue());
         }
     }
 }
Esempio n. 7
0
 public static string WaitForPacket(FakeNetworkClient client)
 {
     while (true)
     {
         if (client.SentPackets.Count > 0)
         {
             string packet = client.SentPackets.Dequeue();
             Debug.WriteLine($"Dequeued {packet}");
             return(packet);
         }
     }
 }
Esempio n. 8
0
 public static string WaitForPacket(FakeNetworkClient client, string packetHeader)
 {
     while (true)
     {
         if (client.SentPackets.Count > 0)
         {
             string packet = client.SentPackets.Dequeue();
             if (packet != null && packet.StartsWith(packetHeader))
             {
                 return(packet);
             }
         }
     }
 }
Esempio n. 9
0
        public static FakeNetworkClient CreateFakeNetworkClient()
        {
            FakeNetworkClient client = new FakeNetworkClient();

            _sessionManager.AddSession(client);

            long       id      = ServerManager.RandomNumber(0, 999999);
            AccountDTO account = new AccountDTO
            {
                AccountId   = id,
                Authority   = AuthorityType.Admin,
                LastSession = 12345,
                Name        = "test" + id,
                Password    = "******"
            };

            DAOFactory.AccountDAO.InsertOrUpdate(ref account);

            // register for account login
            ServerCommunicationClient.Instance.HubProxy.Invoke("RegisterAccountLogin", account.Name, 12345);

            // OpenNosEntryPoint -> LoadCharacterList
            client.ReceivePacket("12345");
            client.ReceivePacket(account.Name);
            client.ReceivePacket("test");

            string clistStart = WaitForPacket(client);

            string clistEnd = WaitForPacket(client);

            // creation of character
            client.ReceivePacket($"Char_NEW {account.Name} 2 1 0 9");

            List <string> clistAfterCreate = WaitForPackets(client, 3);
            CListPacket   cListPacket      = PacketFactory.Deserialize <CListPacket>(clistAfterCreate[1]);

            // select character
            client.ReceivePacket($"select {cListPacket.Slot}");
            string okPacket = WaitForPacket(client);

            // start game
            client.ReceivePacket("game_start");
            List <string> gameStartPacketsFirstPart  = WaitForPackets(client, "p_clear");
            List <string> gameStartPacketsSecondPart = WaitForPackets(client, "p_clear");

            // wait 100 milliseconds to be sure initialization has been finished
            Thread.Sleep(100);

            return(client);
        }
Esempio n. 10
0
        public static List <string> WaitForPackets(FakeNetworkClient client, int amount)
        {
            int           receivedPackets = 0;
            List <string> packets         = new List <string>();

            while (receivedPackets < amount)
            {
                if (client.SentPackets.Count > 0)
                {
                    packets.Add(client.SentPackets.Dequeue());
                    receivedPackets++;
                }
            }

            return(packets);
        }
Esempio n. 11
0
        public void TestCharacterOption()
        {
            // login, create character, start game
            FakeNetworkClient client = HandlerTestHelper.InitializeTestEnvironment();

            CharacterOptionPacket optionPacket = new CharacterOptionPacket {
                IsActive = false, Option = CharacterOption.FamilyRequestBlocked
            };

            // check family request
            client.ReceivePacket(optionPacket);
            string msgPacket = HandlerTestHelper.WaitForPacket(client, "msg");

            Assert.IsTrue(client.Session.Character.FamilyRequestBlocked);

            HandlerTestHelper.ShutdownTestingEnvironment();
            Assert.Pass();
        }
Esempio n. 12
0
        public static string WaitForPacket(FakeNetworkClient client)
        {
            DateTime startTime = DateTime.Now;

            while (true)
            {
                if (client.SentPackets.Count > 0)
                {
                    string packet = client.SentPackets.Dequeue();
                    Debug.WriteLine($"Dequeued {packet}");
                    return(packet);
                }

                // exit token
                if (startTime.AddSeconds(10) < DateTime.Now)
                {
                    Assert.Fail($"Timed out while waiting for a Packet.");
                    return(string.Empty);
                }
            }
        }
Esempio n. 13
0
        public void TestWalkMove()
        {
            // login, create character, start game
            FakeNetworkClient client = HandlerTestHelper.InitializeTestEnvironment();

            WalkPacket walkPacket = new WalkPacket {
                Speed = 11, XCoordinate = 89, YCoordinate = 126
            };

            // send walkpacket to client
            client.ReceivePacket(walkPacket);

            string     mvPacket   = HandlerTestHelper.WaitForPacket(client, "mv");
            MovePacket movePacket = PacketFactory.Deserialize <MovePacket>(mvPacket);

            Assert.AreEqual(walkPacket.XCoordinate, movePacket.PositionX);
            Assert.AreEqual(walkPacket.YCoordinate, movePacket.PositionY);
            Assert.AreEqual(walkPacket.Speed, movePacket.Speed);

            HandlerTestHelper.ShutdownTestingEnvironment();
            Assert.Pass();
        }
Esempio n. 14
0
        public static FakeNetworkClient InitializeTestEnvironment()
        {
            System.Globalization.CultureInfo.DefaultThreadCurrentUICulture = System.Globalization.CultureInfo.GetCultureInfo("en-US");

            // initialize Logger
            Logger.InitializeLogger(LogManager.GetLogger(typeof(BasicPacketHandlerTest)));

            // create server entities (this values would have been imported)
            CreateServerItems();
            CreateServerMaps();
            CreateServerSkills();

            // initialize servermanager
            ServerManager.Initialize();

            // initialize WCF
            ServiceFactory.Instance.Initialize();

            // register mappings for items
            DAOFactory.InventoryDAO.RegisterMapping(typeof(SpecialistInstance));
            DAOFactory.InventoryDAO.RegisterMapping(typeof(WearableInstance));
            DAOFactory.InventoryDAO.RegisterMapping(typeof(UsableInstance));
            DAOFactory.InventoryDAO.InitializeMapper(typeof(ItemInstance));

            // initialize PacketSerialization
            PacketFactory.Initialize <WalkPacket>();

            // initialize new manager
            _sessionManager = new NetworkManager <TestEncryption>("127.0.0.1", 1234, typeof(CharacterScreenPacketHandler), typeof(TestEncryption), true);
            FakeNetworkClient client = new FakeNetworkClient();

            _sessionManager.AddSession(client);

            AccountDTO account = new AccountDTO()
            {
                AccountId   = 1,
                Authority   = AuthorityType.Admin,
                LastSession = 12345,
                Name        = "test",
                Password    = "******"
            };

            DAOFactory.AccountDAO.InsertOrUpdate(ref account);

            // register for account login
            ServiceFactory.Instance.CommunicationService.RegisterAccountLogin("test", 12345);

            // OpenNosEntryPoint -> LoadCharacterList
            client.ReceivePacket("12345");
            client.ReceivePacket("test");
            client.ReceivePacket("test");

            string clistStart = WaitForPacket(client);

            string clistEnd = WaitForPacket(client);

            // creation of character
            client.ReceivePacket("Char_NEW Test 2 1 0 9");

            List <string> clistAfterCreate = WaitForPackets(client, 3);
            CListPacket   cListPacket      = PacketFactory.Serialize <CListPacket>(clistAfterCreate[1]);

            // select character
            client.ReceivePacket($"select {cListPacket.Slot}");
            string okPacket = WaitForPacket(client);

            // start game
            client.ReceivePacket("game_start");
            List <string> gameStartPacketsFirstPart  = WaitForPackets(client, "p_clear");
            List <string> gameStartPacketsSecondPart = WaitForPackets(client, "p_clear");

            return(client);
        }