OptifitWebService/UnitTestEF/Entities/EventTest.cs

using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore;

namespace UnitTestEF.Entities;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Infrastructure;
using Infrastructure.Entities;

[TestClass]
public class EventTest
{
    [TestMethod]
    public async Task AddEventTest()
    {
        var connection = new SqliteConnection("DataSource=:memory:");
        connection.Open();
        var options = new DbContextOptionsBuilder<AlumniDbContext>()
            .UseSqlite(connection)
            .Options;
        using (var context = new AlumniDbContext(options))
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();
            var newEvent = new EventEntity
            {
                Id = "1",
                Title = "A Test Event",
                Description = "A Test Description",
                Date = new DateTime(2020, 9, 1),
                nbPlaces = 50
            };
            await context.Events.AddAsync(newEvent);
            await context.SaveChangesAsync();
            
            Assert.AreEqual(1, await context.Events.CountAsync());
            
            var inBaseEvent = await context.Events.FirstOrDefaultAsync(e => e.Id == "1");
            Assert.IsNotNull(inBaseEvent);
            Assert.AreEqual("1", inBaseEvent.Id);
            Assert.AreEqual("A Test Event", inBaseEvent.Title);
            Assert.AreEqual("A Test Description", inBaseEvent.Description);
            Assert.AreEqual(new DateTime(2020, 9, 1), inBaseEvent.Date);
            Assert.AreEqual(50, inBaseEvent.nbPlaces);
        }
    }
    
    [TestMethod]
    public async Task RemoveEventTest()
    {
        var connection = new SqliteConnection("DataSource=:memory:");
        connection.Open();
        var options = new DbContextOptionsBuilder<AlumniDbContext>()
            .UseSqlite(connection)
            .Options;
        using (var context = new AlumniDbContext(options))
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();
            var newEvent = new EventEntity
            {
                Id = "1",
                Title = "A Test Event",
                Description = "A Test Description",
                Date = new DateTime(2020, 9, 1),
                nbPlaces = 50
            };
            await context.Events.AddAsync(newEvent);
            await context.SaveChangesAsync();
            
            var inBaseEvent = await context.Events.FirstOrDefaultAsync(e => e.Id == "1");
            Assert.IsNotNull(inBaseEvent);
            
            context.Events.Remove(newEvent);
            await context.SaveChangesAsync();
            
            var eventAfterDelete = await context.Events.FirstOrDefaultAsync(e => e.Id == "1");
            Assert.IsNull(eventAfterDelete);
        }
    }
    
    [TestMethod]
    public async Task UpdateEventTest()
    {
        var connection = new SqliteConnection("DataSource=:memory:");
        connection.Open();
        var options = new DbContextOptionsBuilder<AlumniDbContext>()
            .UseSqlite(connection)
            .Options;
        using (var context = new AlumniDbContext(options))
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();
            var newEvent = new EventEntity
            {
                Id = "1",
                Title = "A Test Event",
                Description = "A Test Description",
                Date = new DateTime(2020, 9, 1),
                nbPlaces = 50
            };
            await context.Events.AddAsync(newEvent);
            await context.SaveChangesAsync();
            
            var inBaseEvent = await context.Events.FirstOrDefaultAsync(e => e.Id == "1");
            Assert.IsNotNull(inBaseEvent);
            
            inBaseEvent.Title = "A New Title";
            inBaseEvent.Description = "A New Description";
            inBaseEvent.Date = new DateTime(2020, 9, 2);
            inBaseEvent.nbPlaces = 100;
            await context.SaveChangesAsync();
            
            var eventAfterUpdate = await context.Events.FirstOrDefaultAsync(e => e.Id == "1");
            Assert.IsNotNull(eventAfterUpdate);
            Assert.AreEqual("1", eventAfterUpdate.Id);
            Assert.AreEqual("A New Title", eventAfterUpdate.Title);
            Assert.AreEqual("A New Description", eventAfterUpdate.Description);
            Assert.AreEqual(new DateTime(2020, 9, 2), eventAfterUpdate.Date);
            Assert.AreEqual(100, eventAfterUpdate.nbPlaces);
        }
    }
    
    [TestMethod]
    public async Task EventWithParticipantsTest()
    {
        var connection = new SqliteConnection("DataSource=:memory:");
        connection.Open();
        var options = new DbContextOptionsBuilder<AlumniDbContext>()
            .UseSqlite(connection)
            .Options;
        using (var context = new AlumniDbContext(options))
        {
            context.Database.EnsureDeleted();
            context.Database.EnsureCreated();
            var newEvent = new EventEntity
            {
                Id = "1",
                Title = "A Test Event",
                Description = "A Test Description",
                Date = new DateTime(2020, 9, 1),
                nbPlaces = 50
            };
            await context.Events.AddAsync(newEvent);
            await context.SaveChangesAsync();
            
            var inBaseEvent = await context.Events.FirstOrDefaultAsync(e => e.Id == "1");
            Assert.IsNotNull(inBaseEvent);
            
            var participants = new List<User>(
                [
                    new User
                    {
                        Id = "1",
                        FirstName = "Test",
                        LastName = "Test",
                        Email = "test@gmail.com",
                        EntryYear = "2021",
                        Password = "1234567890",
                        Role = "ADMIN"
                    },
                    new User
                    {
                        Id = "2",
                        FirstName = "Test2",
                        LastName = "Test2",
                        Email = "test2@gmail.com",
                        EntryYear = "2021",
                        Password = "1234567890",
                        Role = "USER",
                    }
                ]
            );
            
            foreach (var p in participants)
            {
                inBaseEvent.Participants.Add(p);
            }
            
            await context.SaveChangesAsync();
            
            var eventWithParticipants = await context.Events.Include(e => e.Participants).FirstOrDefaultAsync(e => e.Id == "1");
            Assert.IsNotNull(eventWithParticipants);
            Assert.AreEqual(2, eventWithParticipants.Participants.Count);
            
            foreach (var p in eventWithParticipants.Participants)
            {
                Assert.IsTrue(participants.Contains(p));
            }
        }
    }
    
    [TestMethod]
    public void ToString_ReturnsCorrectFormat()
    {
        // Arrange
        var eventEntity = new EventEntity
        {
            Title = "Test Event",
            Description = "This is a test event",
            Date = new DateTime(2022, 1, 1),
            nbPlaces = 100
        };

        // Act
        var result = eventEntity.ToString();

        // Assert
        var expected = "\tTitle: Test Event, Date: 01/01/2022 00:00:00, nbPlaces: 100";
        Assert.AreEqual(expected, result);
    }
}