Refactor tests to have less redundancy

[JonasMuehlmann]

Every test method has setup that is quite extensive in many and completely redundant in almost all cases.
To minimize the boilerplate code used for creating needed data, I am thinking about having global variables for the id's of common DB entries(maybe we can even save whole objects?) and provide a simple function to set up needed data.
Alternatively, we could add a [TestInitialize] attributed method to set up all available entries, reducing the number of code lines needed for setup to 0.

The setup function could create a dictionary.

A function like

        [TestMethod]
        public void ResolveMentionNoMention_Test()
        {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;

            Task.Run(async () =>
            {
                uint? teamId = await TeamService.CreateTeam(testName + "Team");
                Assert.IsNotNull(teamId);

                string userId = (await UserService.GetOrCreateApplicationUser(new User(){Id= testName + "UserId" ,DisplayName = testName + "UserName"})).Id;
                Assert.IsNotNull(userId);

                uint? channelId = await ChannelService.CreateChannel(testName + "Channel", teamId.Value);
                Assert.IsNotNull(channelId);

                uint? messageId = await MessageService.CreateMessage(channelId.Value, userId, testName + "Message");
                Assert.IsNotNull(messageId);

                uint? mentionId = await MentionService.CreateMention(MentionTarget.User, userId);
                Assert.IsNotNull(mentionId);

                var messageOriginal = (await MessageService.GetMessage(messageId.Value)).Content;
                Assert.AreEqual(testName + "Message", messageOriginal);

                var messageResolved = await MentionService.ResolveMentions(messageOriginal);
                Assert.AreEqual(messageOriginal, messageResolved);
            }).GetAwaiter().GetResult();
        }

could then be reduced to

        [TestMethod]
        public void ResolveMentionNoMention_Test()
        {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var data = Setup(Entity.User, Entity.Team, Entity.Channel, Entity.Message, Entity.Mention);

            Task.Run(async () =>
            {


                var messageOriginal = (await MessageService.GetMessage(messageId.Value)).Content;
                Assert.AreEqual(testName + "Message", messageOriginal);

                var messageResolved = await MentionService.ResolveMentions(messageOriginal);
                Assert.AreEqual(messageOriginal, messageResolved);
            }).GetAwaiter().GetResult();
        }

or like this, generating all data with defaults but executing a custom generator for the user:

        [TestMethod]
        public void ResolveMentionNoMention_Test()
        {
            var testName = System.Reflection.MethodBase.GetCurrentMethod().Name;
            var data = Setup(username=() => {/* my custom user generator here */});

            Task.Run(async () =>
            {
                var messageOriginal = (await MessageService.GetMessage(messageId.Value)).Content;
                Assert.AreEqual(testName + "Message", messageOriginal);

                var messageResolved = await MentionService.ResolveMentions(messageOriginal);
                Assert.AreEqual(messageOriginal, messageResolved);
            }).GetAwaiter().GetResult();
        }

This improves readability greatly by refactoring out non-essential code and leaving behind the actual test scenario(Resolving a mention in this case).