Esempio n. 1
0
        public void UserIsInGame_ValidPlayer2()
        {
            var mockPlayer1 = new Mock <IGuildUser>();

            mockPlayer1.Setup(u => u.Id).Returns(121);

            var mockPlayer2 = new Mock <IGuildUser>();

            mockPlayer2.Setup(u => u.Id).Returns(122);

            const bool expectedUserIsPlaying = true;

            string joinResult1          = TicTacToeProvider.AttemptPlayerJoin(mockPlayer1.Object);
            string joinResult2          = TicTacToeProvider.AttemptPlayerJoin(mockPlayer2.Object);
            bool   actualPlayer1Playing = TicTacToeProvider.UserIsInGame(mockPlayer1.Object);
            bool   actualPlayer2Playing = TicTacToeProvider.UserIsInGame(mockPlayer2.Object);
            bool   actualGameInProgress = TicTacToeProvider.GameIsInProgress();

            TicTacToeProvider.ForceGameRestart();

            Assert.AreEqual(true, actualGameInProgress);
            Assert.AreEqual(TicTacToeProvider.sucPlayer1Joined, joinResult1);
            Assert.AreEqual(TicTacToeProvider.sucPlayer2Joined, joinResult2);
            Assert.AreEqual(expectedUserIsPlaying, actualPlayer1Playing);
            Assert.AreEqual(expectedUserIsPlaying, actualPlayer2Playing);
        }
Esempio n. 2
0
        public void UserIsInGame_NullRef()
        {
            const bool expected = false;

            bool actual = TicTacToeProvider.UserIsInGame(null);

            Assert.AreEqual(expected, actual);
        }
Esempio n. 3
0
        public void UserIsInGame_NonPlayingUser()
        {
            var mockNonPlayingUser = new Mock <IGuildUser>();

            mockNonPlayingUser.Setup(u => u.Id).Returns(120);

            const bool expected = false;

            bool actual = TicTacToeProvider.UserIsInGame(mockNonPlayingUser.Object);

            Assert.NotNull(mockNonPlayingUser.Object);
            Assert.AreEqual(expected, actual);
        }
Esempio n. 4
0
        public void UserIsInGame_ValidPlayer1()
        {
            var mockPlayer = new Mock <IGuildUser>();

            mockPlayer.Setup(u => u.Id).Returns(121);

            const bool expected = true;

            string joinResult = TicTacToeProvider.AttemptPlayerJoin(mockPlayer.Object);
            bool   actual     = TicTacToeProvider.UserIsInGame(mockPlayer.Object);

            TicTacToeProvider.ForceGameRestart();

            Assert.AreEqual(TicTacToeProvider.sucPlayer1Joined, joinResult);
            Assert.AreEqual(expected, actual);
        }
Esempio n. 5
0
        public async Task TicTacToeStart()
        {
            string resultString = TicTacToeProvider.AttemptPlayerJoin((SocketGuildUser)Context.User);
            string title        = "Error";
            string description  = "Something is wrong in the code..";

            if (resultString == TicTacToeProvider.sucPlayer2Joined)
            {
                title       = "Success!";
                description = $"{Context.User.Mention} is now player 2!";
                await SendEmbeddedMessage(title, description);
                await SendEmbeddedMessage("", TicTacToeProvider.StartGame());

                return;
            }

            if (resultString == TicTacToeProvider.errGameInProgress)
            {
                title       = "Failed to join game";
                description = "Please wait for the current game to finish before starting a new one.";
            }

            if (resultString == TicTacToeProvider.errUserAlreadyPlaying)
            {
                title       = "Failed to join game";
                description = "You've already joined the game. The game will start when another player joins.";
            }

            if (resultString == TicTacToeProvider.sucPlayer1Joined)
            {
                title       = "Success!";
                description = $"{Context.User.Mention} is now player 1!";
            }

            await SendEmbeddedMessage(title, description);
        }