Discord.Net/test/Discord.Net.Tests/Tests.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Discord.Tests
{
    //TODO: Tests are massively incomplete and out of date, needing a full rewrite

    [TestClass]
    public class Tests
    {
        private const int EventTimeout = 10000; //Max time in milliseconds to wait for an event response from our test actions

        private static DiscordSocketClient _hostBot, _targetBot, _observerBot;
        private static Guild _testGuild;
        private static TextChannel _testGuildChannel;
        private static Random _random;
        private static PublicInvite _testGuildInvite;

        private static TestContext _context;

        private static string _hostToken;
        private static string _observerToken;
        private static string _targetToken;

        private static string GetRandomText()
        {
            lock (_random)
                return $"test_{_random.Next()}";
        }

        #region Initialization

        [ClassInitialize]
        public static void Initialize(TestContext testContext)
        {
            _context = testContext;

            _hostToken = Environment.GetEnvironmentVariable("discord-unit-host_token");
            _observerToken = Environment.GetEnvironmentVariable("discord-unit-observer_token");
            _targetToken = Environment.GetEnvironmentVariable("discord-unit-target_token");
        }

        [TestMethod]
        [Priority(1)]
        public async Task TestInitialize()
        {
            _context.WriteLine("Initializing.");

            _random = new Random();

            _hostBot = new DiscordSocketClient(_hostToken);
            _targetBot = new DiscordSocketClient(_targetToken);
            _observerBot = new DiscordSocketClient(_observerToken);

            await _hostBot.Login();

            await Task.Delay(3000);

            //Cleanup existing Guilds
            (await _hostBot.GetGuilds()).Select(x => x.Owner.Id == _hostBot.CurrentUser.Id ? x.Delete() : x.Leave());

            //Create new Guild and invite the other bots to it

            _testGuild = await _hostBot.CreateGuild("Discord.Net Testing", _hostBot.GetOptimalVoiceRegion());

            await Task.Delay(1000);

            PublicInvite invite = await _testGuild.CreateInvite(60, 3, false, false);
            _testGuildInvite = invite;

            _context.WriteLine($"Host: {_hostBot.CurrentUser.Username} in {(await _hostBot.GetGuilds()).Count()}");
        }

        [TestMethod]
        [Priority(2)]
        public async Task TestTokenLogin_Ready()
        {
            AssertEvent(
                "READY never received",
                async () => await _observerBot.Login(),
                x => _observerBot.Connected += x,
                x => _observerBot.Connected -= x,
                null,
                true);
            (await _observerBot.GetGuilds()).Select(x => x.Owner.Id == _observerBot.CurrentUser.Id ? x.Delete() : x.Leave());
            await _observerBot.RestClient.Send(new API.Rest.AcceptInviteRequest(_testGuildInvite.Code));
        }

        [TestMethod]
        [Priority(2)]
        public async Task TestReady()
        {
            AssertEvent(
                "READY never received",
                async () => await _targetBot.Login(),
                x => _targetBot.Connected += x,
                x => _targetBot.Connected -= x,
                null,
                true);

            (await _targetBot.GetGuilds()).Select(x => x.Owner.Id == _targetBot.CurrentUser.Id ? x.Delete() : x.Leave());
            _testGuildChannel = _testGuild.DefaultChannel;
        }

        #endregion

        // Guilds

        #region Guild Tests

        [TestMethod]
        [Priority(3)]
        public void TestJoinedGuild()
        {
            AssertEvent<GuildEventArgs>(
                "Never Got JoinedGuild",
                async () => await _targetBot.RestClient.Send(new API.Rest.AcceptInviteRequest(_testGuildInvite.Code)),
                x => _targetBot.JoinedGuild += x,
                x => _targetBot.JoinedGuild -= x);
        }

        #endregion

        #region Channel Tests

        //Channels
        [TestMethod]
        public void TestCreateTextChannel()
        {
            GuildChannel channel = null;
            string name = GetRandomText();
            AssertEvent<ChannelEventArgs>(
                "ChannelCreated event never received",
                async () => channel = await _testGuild.CreateTextChannel(name),
                x => _targetBot.ChannelCreated += x,
                x => _targetBot.ChannelCreated -= x,
                (s, e) => e.Channel.Id == channel.Id);

            AssertEvent<ChannelEventArgs>(
                "ChannelDestroyed event never received",
                async () => await channel.Delete(),
                x => _targetBot.ChannelDestroyed += x,
                x => _targetBot.ChannelDestroyed -= x,
                (s, e) => e.Channel.Id == channel.Id);
        }
        [TestMethod]
        public void TestCreateVoiceChannel()
        {
            GuildChannel channel = null;
            string name = GetRandomText();
            AssertEvent<ChannelEventArgs>(
                "ChannelCreated event never received",
                async () => channel = await _testGuild.CreateVoiceChannel(name),
                x => _targetBot.ChannelCreated += x,
                x => _targetBot.ChannelCreated -= x,
                (s, e) => e.Channel.Id == channel.Id);

            AssertEvent<ChannelEventArgs>(
                "ChannelDestroyed event never received",
                async () => await channel.Delete(),
                x => _targetBot.ChannelDestroyed += x,
                x => _targetBot.ChannelDestroyed -= x,
                (s, e) => e.Channel.Id == channel.Id);
        }

        [TestMethod]
        [ExpectedException(typeof(Net.HttpException))]
        public async Task TestCreateChannel_NoName()
        {
            await _testGuild.CreateTextChannel($"");
        }
        [TestMethod]
        public async Task Test_CreateGetChannel()
        {
            var name = GetRandomText();
            var channel = await _testGuild.CreateTextChannel(name);
            var get_channel = _testGuild.GetChannel(channel.Id);
            Assert.AreEqual(channel.Id, get_channel.Id, "ID of Channel and GetChannel were not equal.");
        }
        [TestMethod]
        public void TestSendTyping()
        {
            var channel = _testGuildChannel;
            AssertEvent<TypingEventArgs>(
                "UserUpdated event never fired.",
                async () => await channel.TriggerTyping(),
                x => _targetBot.UserIsTyping += x,
                x => _targetBot.UserIsTyping -= x);
        }
        [TestMethod]
        public void TestEditChannel()
        {
            var channel = _testGuildChannel;
            AssertEvent<ChannelUpdatedEventArgs>(
                "ChannelUpdated Never Received",
                async () => await channel.Modify(x =>
                {
                    x.Name = GetRandomText();
                    x.Topic = $"topic - {GetRandomText()}";
                    x.Position = 26;
                }),
                x => _targetBot.ChannelUpdated += x,
                x => _targetBot.ChannelUpdated -= x);
        }
        [TestMethod]
        public void TestChannelMention()
        {
            var channel = _testGuildChannel;
            Assert.AreEqual($"<#{channel.Id}>", channel.Mention, "Generated channel mention was not the expected channel mention.");
        }
        [TestMethod]
        public void TestChannelUserCount()
        {
            Assert.AreEqual(3, _testGuildChannel.Users.Count(), "Read an incorrect number of users in a channel");
        }

        #endregion

        #region Message Tests

        //Messages
        [TestMethod]
        public async Task TestMessageEvents()
        {
            string name = GetRandomText();
            var channel = await _testGuild.CreateTextChannel(name);
            _context.WriteLine($"Channel Name: {channel.Name} / {channel.Guild.Name}");
            string text = GetRandomText();
            Message message = null;
            AssertEvent<MessageEventArgs>(
                "MessageCreated event never received",
                async () => message = await channel.SendMessage(text),
                x => _targetBot.MessageReceived += x,
                x => _targetBot.MessageReceived -= x,
                (s, e) => e.Message.Text == text);

            AssertEvent<MessageUpdatedEventArgs>(
                "MessageUpdated event never received",
                async () => await message.Modify(x =>
                {
                    x.Content = text + " updated";
                }),
                x => _targetBot.MessageUpdated += x,
                x => _targetBot.MessageUpdated -= x,
                (s, e) => e.Before.Text == text && e.After.Text == text + " updated");

            AssertEvent<MessageEventArgs>(
                "MessageDeleted event never received",
                async () => await message.Delete(),
                x => _targetBot.MessageDeleted += x,
                x => _targetBot.MessageDeleted -= x,
                (s, e) => e.Message.Id == message.Id);
        }
        [TestMethod]
        public async Task TestDownloadMessages()
        {
            string name = GetRandomText();
            var channel = await _testGuild.CreateTextChannel(name);
            for (var i = 0; i < 10; i++) await channel.SendMessage(GetRandomText());
            while (channel.Discord.MessageQueue.Count > 0) await Task.Delay(100);
            var messages = await channel.GetMessages(10);
            Assert.AreEqual(10, messages.Count(), "Expected 10 messages in downloaded array, did not see 10.");
        }
        [TestMethod]
        public async Task TestSendTTSMessage()
        {
            var channel = await _testGuild.CreateTextChannel(GetRandomText());
            AssertEvent<MessageEventArgs>(
                "MessageCreated event never fired",
                async () => await channel.SendMessage(GetRandomText(), true),
                x => _targetBot.MessageReceived += x,
                x => _targetBot.MessageReceived -= x,
                (s, e) => e.Message.IsTTS);
        }

        #endregion

        #region User Tests

        [TestMethod]
        public async Task TestUserMentions()
        {
            var user = (await _targetBot.GetGuild(_testGuild.Id)).CurrentUser;
            Assert.AreEqual($"<@{user.Id}>", user.Mention);
        }
        [TestMethod]
        public void TestUserEdit()
        {
            var user = _testGuild.GetUser(_targetBot.CurrentUser.Id);
            AssertEvent<UserUpdatedEventArgs>(
                "UserUpdated never fired",
                async () => await user.Modify(x =>
                {
                    x.Deaf = true;
                    x.Mute = true;
                }),
                x => _targetBot.UserUpdated += x,
                x => _targetBot.UserUpdated -= x);
        }
        [TestMethod]
        public void TestEditSelf()
        {
            throw new NotImplementedException();
            /*var name = RandomText
            AssertEvent<UserUpdatedEventArgs>(
                "UserUpdated never fired",
                async () => await _targetBot.CurrentUser.Modify(TargetPassword, name),
                x => _obGuildBot.UserUpdated += x,
                x => _obGuildBot.UserUpdated -= x,
                (s, e) => e.After.Username == name);*/
        }
        [TestMethod]
        public void TestSetStatus()
        {
            AssertEvent<UserUpdatedEventArgs>(
                "UserUpdated never fired",
                async () => await SetStatus(_targetBot, UserStatus.Idle),
                x => _observerBot.UserUpdated += x,
                x => _observerBot.UserUpdated -= x,
                (s, e) => e.After.Status == UserStatus.Idle);
        }
        private Task SetStatus(DiscordClient _client, UserStatus status)
        {
            throw new NotImplementedException();
            /*_client.SetStatus(status);
            await Task.Delay(50);*/
        }
        [TestMethod]
        public void TestSetGame()
        {
            AssertEvent<UserUpdatedEventArgs>(
                "UserUpdated never fired",
                async () => await SetGame(_targetBot, "test game"),
                x => _observerBot.UserUpdated += x,
                x => _observerBot.UserUpdated -= x,
                (s, e) => _targetBot.CurrentUser.CurrentGame == "test game");

        }
        private Task SetGame(DiscordClient _client, string game)
        {
            throw new NotImplementedException();
            //_client.SetGame(game);
            //await Task.Delay(5);
        }

        #endregion

        #region Permission Tests

        // Permissions
        [TestMethod]
        public async Task Test_AddGet_PermissionsRule()
        {
            var channel = await _testGuild.CreateTextChannel(GetRandomText());
            var user = _testGuild.GetUser(_targetBot.CurrentUser.Id);
            var perms = new OverwritePermissions(sendMessages: PermValue.Deny);
            await channel.UpdatePermissionOverwrite(user, perms);
            var resultPerms = channel.GetPermissionOverwrite(user);
            Assert.IsNotNull(resultPerms, "Perms retrieved from Guild were null.");
        }
        [TestMethod]
        public async Task Test_AddRemove_PermissionsRule()
        {
            var channel = await _testGuild.CreateTextChannel(GetRandomText());
            var user = _testGuild.GetUser(_targetBot.CurrentUser.Id);
            var perms = new OverwritePermissions(sendMessages: PermValue.Deny);
            await channel.UpdatePermissionOverwrite(user, perms);
            await channel.RemovePermissionOverwrite(user);
            await Task.Delay(200);
            Assert.AreEqual(PermValue.Inherit, channel.GetPermissionOverwrite(user)?.SendMessages);
        }
        [TestMethod]
        public async Task Test_Permissions_Event()
        {
            var channel = await _testGuild.CreateTextChannel(GetRandomText());
            var user = _testGuild.GetUser(_targetBot.CurrentUser.Id);
            var perms = new OverwritePermissions(sendMessages: PermValue.Deny);
            AssertEvent<ChannelUpdatedEventArgs>
                ("ChannelUpdatedEvent never fired.",
                async () => await channel.UpdatePermissionOverwrite(user, perms),
                x => _targetBot.ChannelUpdated += x,
                x => _targetBot.ChannelUpdated -= x,
                (s, e) => e.Channel == channel && (e.After as GuildChannel).PermissionOverwrites.Count() != (e.Before as GuildChannel).PermissionOverwrites.Count());
        }
        [TestMethod]
        [ExpectedException(typeof(Net.HttpException))]
        public async Task Test_Affect_Permissions_Invalid_Channel()
        {
            var channel = await _testGuild.CreateTextChannel(GetRandomText());
            var user = _testGuild.GetUser(_targetBot.CurrentUser.Id);
            var perms = new OverwritePermissions(sendMessages: PermValue.Deny);
            await channel.Delete();
            await channel.UpdatePermissionOverwrite(user, perms);
        }

        #endregion


        [ClassCleanup]
        public static async Task Cleanup()
        {
            WaitMany(
                (await _hostBot.GetGuilds()).Select(x => x.Owner.Id == _hostBot.CurrentUser.Id ? x.Delete() : x.Leave()),
                (await _targetBot.GetGuilds()).Select(x => x.Owner.Id == _targetBot.CurrentUser.Id ? x.Delete() : x.Leave()),
                (await _observerBot.GetGuilds()).Select(x => x.Owner.Id == _observerBot.CurrentUser.Id ? x.Delete() : x.Leave()));

            WaitAll(
                _hostBot.Disconnect(),
                _targetBot.Disconnect(),
                _observerBot.Disconnect());
        }

        #region Helpers

        // Task Helpers

        private static void AssertEvent<TArgs>(string msg, Func<Task> action, Action<EventHandler<TArgs>> addEvent, Action<EventHandler<TArgs>> removeEvent, Func<object, TArgs, bool> test = null)
        {
            AssertEvent(msg, action, addEvent, removeEvent, test, true);
        }
        private static void AssertNoEvent<TArgs>(string msg, Func<Task> action, Action<EventHandler<TArgs>> addEvent, Action<EventHandler<TArgs>> removeEvent, Func<object, TArgs, bool> test = null)
        {
            AssertEvent(msg, action, addEvent, removeEvent, test, false);
        }
        private static void AssertEvent<TArgs>(string msg, Func<Task> action, Action<EventHandler<TArgs>> addEvent, Action<EventHandler<TArgs>> removeEvent, Func<object, TArgs, bool> test, bool assertTrue)
        {
            ManualResetEventSlim trigger = new ManualResetEventSlim(false);
            bool result = false;

            EventHandler<TArgs> handler = (s, e) =>
            {
                if (test != null)
                {
                    result |= test(s, e);
                    trigger.Set();
                }
                else
                    result = true;
            };

            addEvent(handler);
            var task = action();
            trigger.Wait(EventTimeout);
            task.Wait();
            removeEvent(handler);

            Assert.AreEqual(assertTrue, result, msg);
        }

        private static void AssertEvent(string msg, Func<Task> action, Action<EventHandler> addEvent, Action<EventHandler> removeEvent, Func<object, bool> test, bool assertTrue)
        {
            ManualResetEventSlim trigger = new ManualResetEventSlim(false);
            bool result = false;

            EventHandler handler = (s, e) =>
            {
                if (test != null)
                {
                    result |= test(s);
                    trigger.Set();
                }
                else
                    result = true;
            };

            addEvent(handler);
            var task = action();
            trigger.Wait(EventTimeout);
            task.Wait();
            removeEvent(handler);

            Assert.AreEqual(assertTrue, result, msg);
        }

        private static void WaitAll(params Task[] tasks)
        {
            Task.WaitAll(tasks);
        }
        private static void WaitAll(IEnumerable<Task> tasks)
        {
            Task.WaitAll(tasks.ToArray());
        }
        private static void WaitMany(params IEnumerable<Task>[] tasks)
        {
            Task.WaitAll(tasks.Where(x => x != null).SelectMany(x => x).ToArray());
        }

        #endregion
    }
}