TourIAm/TIAM.Database.Test/UserDalTests.cs

using AyCode.Database.Tests;
using Microsoft.EntityFrameworkCore;
using Microsoft.VisualStudio.TestPlatform.ObjectModel;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using TIAM.Database.DataLayers.Users;
using TIAM.Database.DbContexts;
using TIAM.Entities.Users;

namespace TIAM.Database.Test
{
    [TestClass]
    public class UserDalTests : DatabaseTestModelBase
    {
        private Mock<UserDbContext> _mockContext;
        private UserDal _userDal;

        [TestInitialize]
        public void TestInitialize()
        {
            var options = new DbContextOptionsBuilder<UserDbContext>()
                .UseInMemoryDatabase(databaseName: "UserDatabase")
                .Options;

            _mockContext = new Mock<UserDbContext>(options);

            var mockSet = new Mock<DbSet<User>>();
            _mockContext.Setup(c => c.Users).Returns(mockSet.Object);

            _userDal = new UserDal(_mockContext.Object);
        }

        [TestMethod]
        [DataRow("test@tiam.hu")]
        public async Task GetUserByEmailAsync_ReturnsUser_WhenUserExists(string email)
        {
            // Arrange
            var user = new User { Email = email };
            var users = new[] { user }.AsQueryable();

            var mockSet = new Mock<DbSet<User>>();
            mockSet.As<IQueryable<User>>().Setup(m => m.Provider).Returns(users.Provider);
            mockSet.As<IQueryable<User>>().Setup(m => m.Expression).Returns(users.Expression);
            mockSet.As<IQueryable<User>>().Setup(m => m.ElementType).Returns(users.ElementType);
            mockSet.As<IQueryable<User>>().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());

            _mockContext.Setup(c => c.Users).Returns(mockSet.Object);

            // Act
            var result = await _userDal.GetUserByEmailAsync(email);

            // Assert
            Assert.IsNotNull(result);
            Assert.AreEqual(email, result.Email);
        }

        [TestMethod]
        [DataRow("test@test.hu")]
        public async Task GetUserByEmailAsync_ReturnsNull_WhenUserDoesNotExist(string email)
        {
            // Arrange
            var users = new User[0].AsQueryable();

            var mockSet = new Mock<DbSet<User>>();
            mockSet.As<IQueryable<User>>().Setup(m => m.Provider).Returns(users.Provider);
            mockSet.As<IQueryable<User>>().Setup(m => m.Expression).Returns(users.Expression);
            mockSet.As<IQueryable<User>>().Setup(m => m.ElementType).Returns(users.ElementType);
            mockSet.As<IQueryable<User>>().Setup(m => m.GetEnumerator()).Returns(users.GetEnumerator());

            _mockContext.Setup(c => c.Users).Returns(mockSet.Object);

            // Act
            var result = await _userDal.GetUserByEmailAsync(email);

            // Assert
            Assert.IsNull(result);
        }

        [TestMethod]
        [DataRow("test@test.com", "+1234567890", "password")]
        public async Task CreateUserAsync_ShouldReturnTrue_WhenUserIsCreated(string email, string phoneNumbr, string password)
        {
            // Arrange
            var user = new User
            {
                Id = Guid.NewGuid(),
                Email = email,
                PhoneNumber = phoneNumbr,
                Password = password
            };

            var mockSet = new Mock<DbSet<User>>();
            _mockContext.Setup(x => x.Users).Returns(mockSet.Object);
            _mockContext.Setup(x => x.Users.Add(user)).Returns(() => null);

            _mockContext.Setup(x => x.SaveChangesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync(1)
            .Verifiable();

            // Act
            var result = await _userDal.CreateUserAsync(user);

            // Assert
            Assert.IsTrue(result);
        }

        [TestMethod]
        [DataRow("test@test.com", "+1234567890", "password")]
        public async Task UpdateUserAsync_ShouldUpdateUser(string email, string phoneNumbr, string password)
        {
            // Arrange
            var user = new User(Guid.NewGuid(), email, phoneNumbr, password);
            _mockContext.Object.Users.Add(user);
            await _mockContext.Object.SaveChangesAsync();

            // Act
            user.Email = email;
            var result = await _userDal.UpdateUserAsync(user);

            // Assert
            Assert.IsTrue(result);
            var updatedUser = _mockContext.Object.Users.Single(u => u.Email == user.Email);
            Assert.AreEqual(email, updatedUser.Email);
        }
    }
}