public async void GetCapsuleByUserBadRequest()
        {
            // Arrange
            var mock = new Mock <ICapsuleRepository>();
            CapsuleController controller = new CapsuleController(mock.Object);

            // Act
            BadRequestObjectResult result = await controller.GetCapsuleByUser(null) as BadRequestObjectResult;

            // Assert
            Assert.Equal(400, result.StatusCode);
            mock.Verify(rep => rep.GetCapsuleByUserAsync(It.IsAny <string>()), Times.Never);
        }
        public async void GetMessageByIdThrowsException()
        {
            // Arrange
            var mock = new Mock <ICapsuleRepository>();

            mock.Setup(rep => rep.GetCapsuleByUserAsync(It.IsAny <string>())).Throws <CapsuleDomainException>();
            CapsuleController controller = new CapsuleController(mock.Object);

            // Act & Assert
            Exception ex = await Assert.ThrowsAsync <CapsuleDomainException>(
                async() => await controller.GetCapsuleByUser("User1")
                );

            Assert.Equal(expected: typeof(CapsuleDomainException), actual: ex.GetType());
        }
        public async void GetCapsuleByUserOk(Models.Capsule[] capsules)
        {
            // Arrange
            var user          = "******";
            var capsuleToFind = capsules[0];
            var mock          = new Mock <ICapsuleRepository>();

            mock.SetupSequence(rep => rep.GetCapsuleByUserAsync(It.IsAny <string>())).Returns(Task <Models.Capsule> .Run(() => capsuleToFind));
            CapsuleController controller = new CapsuleController(mock.Object);

            // Act
            OkObjectResult result = await controller.GetCapsuleByUser(user) as OkObjectResult;

            // Assert
            Assert.Equal((int?)HttpStatusCode.OK, result.StatusCode);
            Assert.Equal(capsuleToFind, (Models.Capsule)result.Value, Comparer.Get <Models.Capsule>((m1, m2) => m1.Id == m2.Id));
        }
        public async void GetCapsuleByUserCreated()
        {
            // Arrange
            string userId = "Unexisting user";
            var    mock   = new Mock <ICapsuleRepository>();

            mock.Setup(rep => rep.GetCapsuleByUserAsync(It.IsAny <string>())).Returns(Task <Models.Capsule> .Run(() => { return(default(Models.Capsule)); }));
            mock.Setup(rep => rep.CreateNewCapsuleAsync(It.IsAny <string>())).Returns(Task <Models.Capsule> .Run(() => { return(new Models.Capsule(userId: userId)); }));
            CapsuleController controller = new CapsuleController(mock.Object);

            // Act
            CreatedAtRouteResult result = await controller.GetCapsuleByUser(userId) as CreatedAtRouteResult;

            // Assert
            Assert.Equal((int?)HttpStatusCode.Created, result.StatusCode);
            Assert.Equal(userId, ((Models.Capsule)result.Value).Id);
            Assert.Empty(((Models.Capsule)result.Value).Messages);
        }