PIBD-23_Matvienko_S.D._MiniSoftProject/MiniSoftContracts/MiniSoftTests/StorageContractsTests/SoftwareStorageContractTest.cs

using Microsoft.EntityFrameworkCore;
using MiniSoftContracts.Data_Models;
using MiniSoftContracts.Enums;
using MiniSoftContracts.Exceptions;
using MiniSoftDatabase.Implementations;
using MiniSoftDatabase.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MiniSoftTests.StorageContractsTests
{
    internal class SoftwareStorageContractTest : BaseStorageContractTest
    {
        private SoftwareStorageContract _softwareStorageContract;
        private Developer _developer;

        [SetUp]
        public void SetUp()
        {
            _softwareStorageContract = new SoftwareStorageContract(MiniSoftDbContext);
            _developer = InsertDeveloperToDatabaseAndReturn();
        }

        [TearDown]
        public void TearDown()
        {
            MiniSoftDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Softwares\" CASCADE;");
            MiniSoftDbContext.Database.ExecuteSqlRaw("TRUNCATE \"Developers\" CASCADE;");
        }

        [Test]
        public void Try_GetList_WhenHaveRecords_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 1");
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 2");
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 3");
            var list = _softwareStorageContract.GetList();
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(3));
            AssertElement(list.First(x => x.Id == Software.Id), Software);
        }

        [Test]
        public void Try_GetList_WhenNoRecords_Test()
        {
            var list = _softwareStorageContract.GetList();
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Is.Empty);
        }

        [Test]
        public void Try_GetList_OnlyActual_Test()
        {
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 1", isDeleted: true);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 2", isDeleted: false);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 3", isDeleted: false);
            var list = _softwareStorageContract.GetList(onlyActive: true);
            Assert.That(list, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(list, Has.Count.EqualTo(2));
                Assert.That(!list.Any(x => x.IsDeleted));
            });
        }

        [Test]
        public void Try_GetList_IncludeNoActual_Test()
        {
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 1", isDeleted: true);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 2", isDeleted: true);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 3", isDeleted: false);
            var list = _softwareStorageContract.GetList(onlyActive: false);
            Assert.That(list, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(list, Has.Count.EqualTo(3));
                Assert.That(list.Count(x => x.IsDeleted), Is.EqualTo(2));
                Assert.That(list.Count(x => !x.IsDeleted), Is.EqualTo(1));
            });
        }

        [Test]
        public void Try_GetList_ByDeveloper_Test()
        {
            var manufacruer = InsertDeveloperToDatabaseAndReturn("name 2");
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 1", isDeleted: true);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 2", isDeleted: false);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), manufacruer.Id, "name 3", isDeleted: false);
            var list = _softwareStorageContract.GetList(devId: _developer.Id, onlyActive: false);
            Assert.That(list, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(list, Has.Count.EqualTo(2)); //???
                Assert.That(list.All(x => x.DeveloperId == _developer.Id));
            });
        }

        [Test]
        public void Try_GetList_ByDeveloperOnlyActual_Test()
        {
            var manufacruer = InsertDeveloperToDatabaseAndReturn("name 2");
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 1", isDeleted: true);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 2", isDeleted: false);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), manufacruer.Id, "name 3", isDeleted: false);
            var list = _softwareStorageContract.GetList(devId: _developer.Id, onlyActive: true);
            Assert.That(list, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(list, Has.Count.EqualTo(1));
                Assert.That(list.All(x => x.DeveloperId == _developer.Id && !x.IsDeleted));
            });
        }

        [Test]
        public void Try_GetHistoryBySoftwareId_WhenHaveRecords_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 1");
            InsertSoftwareHistoryToDatabaseAndReturn(Software.Id, 20, DateTime.UtcNow.AddDays(-1));
            InsertSoftwareHistoryToDatabaseAndReturn(Software.Id, 30, DateTime.UtcNow.AddMinutes(-10));
            InsertSoftwareHistoryToDatabaseAndReturn(Software.Id, 40, DateTime.UtcNow.AddDays(1));
            var list = _softwareStorageContract.GetHistoryById(Software.Id);
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(3));
        }

        [Test]
        public void Try_GetHistoryBySoftwareId_WhenNoRecords_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 1");
            InsertSoftwareHistoryToDatabaseAndReturn(Software.Id, 20, DateTime.UtcNow.AddDays(-1));
            InsertSoftwareHistoryToDatabaseAndReturn(Software.Id, 30, DateTime.UtcNow.AddMinutes(-10));
            InsertSoftwareHistoryToDatabaseAndReturn(Software.Id, 40, DateTime.UtcNow.AddDays(1));
            var list = _softwareStorageContract.GetHistoryById(Guid.NewGuid().ToString());
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(0));
        }

        [Test]
        public void Try_GetElementById_WhenHaveRecord_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id);
            AssertElement(_softwareStorageContract.GetElementById(Software.Id), Software);
        }

        [Test]
        public void Try_GetElementById_WhenNoRecord_Test()
        {
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id);
            Assert.That(() => _softwareStorageContract.GetElementById(Guid.NewGuid().ToString()), Is.Null);
        }

        [Test]
        public void Try_GetElementById_WhenRecordHasDeleted_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, isDeleted: true);
            Assert.That(() => _softwareStorageContract.GetElementById(Software.Id), Is.Null);
        }

        [Test]
        public void Try_GetElementByName_WhenHaveRecord_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id);
            AssertElement(_softwareStorageContract.GetElementByName(Software.SoftwareName), Software);
        }

        [Test]
        public void Try_GetElementByName_WhenNoRecord_Test()
        {
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id);
            Assert.That(() => _softwareStorageContract.GetElementByName("name"), Is.Null);
        }

        [Test]
        public void Try_GetElementByName_WhenRecordHasDeleted_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, isDeleted: true);
            Assert.That(() => _softwareStorageContract.GetElementById(Software.SoftwareName), Is.Null);
        }

        [Test]
        public void Try_AddElement_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id, isDeleted: false);
            _softwareStorageContract.AddElement(Software);
            AssertElement(GetSoftwareFromDatabaseById(Software.Id), Software);
        }

        [Test]
        public void Try_AddElement_WhenIsDeletedIsTrue_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id, isDeleted: true);
            Assert.That(() => _softwareStorageContract.AddElement(Software), Throws.Nothing);
            AssertElement(GetSoftwareFromDatabaseById(Software.Id), CreateModel(Software.Id, _developer.Id, isDeleted: false));
        }

        [Test]
        public void Try_AddElement_WhenHaveRecordWithSameId_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id);
            InsertSoftwareToDatabaseAndReturn(Software.Id, _developer.Id, SoftwareName: "name unique");
            Assert.That(() => _softwareStorageContract.AddElement(Software), Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_AddElement_WhenHaveRecordWithSameName_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id, "name unique", isDeleted: false);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, SoftwareName: Software.SoftwareName, isDeleted: false);
            Assert.That(() => _softwareStorageContract.AddElement(Software), Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_AddElement_WhenHaveRecordWithSameNameButOneWasDeleted_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id, "name unique", isDeleted: false);
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, SoftwareName: Software.SoftwareName, isDeleted: true);
            Assert.That(() => _softwareStorageContract.AddElement(Software), Throws.Nothing);
        }

        [Test]
        public void Try_UpdateElement_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id, isDeleted: false);
            InsertSoftwareToDatabaseAndReturn(Software.Id, _developer.Id, isDeleted: false);
            _softwareStorageContract.UpdateElement(Software);
            AssertElement(GetSoftwareFromDatabaseById(Software.Id), Software);
        }

        [Test]
        public void Try_UpdateElement_WhenIsDeletedIsTrue_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id, isDeleted: true);
            InsertSoftwareToDatabaseAndReturn(Software.Id, _developer.Id, isDeleted: false);
            _softwareStorageContract.UpdateElement(Software);
            AssertElement(GetSoftwareFromDatabaseById(Software.Id), CreateModel(Software.Id, _developer.Id, isDeleted: false));
        }

        [Test]
        public void Try_UpdateElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() => _softwareStorageContract.UpdateElement(CreateModel(Guid.NewGuid().ToString(), _developer.Id)), Throws.TypeOf<ElementNotFoundException>());
        }

        [Test]
        public void Try_UpdateElement_WhenHaveRecordWithSameName_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id, "name unique", isDeleted: false);
            InsertSoftwareToDatabaseAndReturn(Software.Id, _developer.Id, SoftwareName: "name");
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, SoftwareName: Software.SoftwareName);
            Assert.That(() => _softwareStorageContract.UpdateElement(Software), Throws.TypeOf<ElementExistsException>());
        }

        [Test]
        public void Try_UpdateElement_WhenHaveRecordWithSameNameButOneWasDeleted_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id, "name unique", isDeleted: false);
            InsertSoftwareToDatabaseAndReturn(Software.Id, _developer.Id, SoftwareName: "name");
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, SoftwareName: Software.SoftwareName, isDeleted: true);
            Assert.That(() => _softwareStorageContract.UpdateElement(Software), Throws.Nothing);
        }

        [Test]
        public void Try_UpdateElement_WhenRecordWasDeleted_Test()
        {
            var Software = CreateModel(Guid.NewGuid().ToString(), _developer.Id);
            InsertSoftwareToDatabaseAndReturn(Software.Id, _developer.Id, isDeleted: true);
            Assert.That(() => _softwareStorageContract.UpdateElement(Software), Throws.TypeOf<ElementNotFoundException>());
        }

        [Test]
        public void Try_DeleteElement_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, isDeleted: false);
            _softwareStorageContract.DeleteElement(Software.Id);
            var element = GetSoftwareFromDatabaseById(Software.Id);
            Assert.Multiple(() =>
            {
                Assert.That(element, Is.Not.Null);
                Assert.That(element!.IsDeleted);
            });
        }

        [Test]
        public void Try_DeleteElement_WhenNoRecordWithThisId_Test()
        {
            Assert.That(() => _softwareStorageContract.DeleteElement(Guid.NewGuid().ToString()), Throws.TypeOf<ElementNotFoundException>());
        }

        [Test]
        public void Try_DeleteElement_WhenRecordWasDeleted_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, isDeleted: true);
            Assert.That(() => _softwareStorageContract.DeleteElement(Software.Id), Throws.TypeOf<ElementNotFoundException>());
        }


        [Test]
        public async Task Try_GetListAsync_WhenHaveRecords_Test()
        {
            var Software = InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 1");
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 2");
            InsertSoftwareToDatabaseAndReturn(Guid.NewGuid().ToString(), _developer.Id, "name 3");
            var list = await _softwareStorageContract.GetListAsync(CancellationToken.None);
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Has.Count.EqualTo(3));
            AssertElement(list.First(x => x.Id == Software.Id), Software);
        }

        [Test]
        public async Task Try_GetListAsync_WhenNoRecords_Test()
        {
            var list = await _softwareStorageContract.GetListAsync(CancellationToken.None);
            Assert.That(list, Is.Not.Null);
            Assert.That(list, Is.Empty);
        }

        private Developer InsertDeveloperToDatabaseAndReturn(string DeveloperName = "name")
        {
            var developer = new Developer() { Id = Guid.NewGuid().ToString(), DeveloperName = DeveloperName };
            MiniSoftDbContext.Developers.Add(developer);
            MiniSoftDbContext.SaveChanges();
            return developer;
        }

        private Software InsertSoftwareToDatabaseAndReturn(string id, string DeveloperId, string SoftwareName = "test", SoftwareType SoftwareType = SoftwareType.OperatingSystem, double price = 1, bool isDeleted = false)
        {
            var Software = new Software() { Id = id, DeveloperId = DeveloperId, SoftwareName = SoftwareName, SoftwareType = SoftwareType, Price = price, IsDeleted = isDeleted };
            MiniSoftDbContext.Softwares.Add(Software);
            MiniSoftDbContext.SaveChanges();
            return Software;
        }

        private SoftwareHistory InsertSoftwareHistoryToDatabaseAndReturn(string SoftwareId, double price, DateTime changeDate)
        {
            var SoftwareHistory = new SoftwareHistory() { Id = Guid.NewGuid().ToString(), SoftwareId = SoftwareId, OldPrice = price, ChangeDate = changeDate };
            MiniSoftDbContext.SoftwareHistories.Add(SoftwareHistory);
            MiniSoftDbContext.SaveChanges();
            return SoftwareHistory;
        }

        private static void AssertElement(SoftwareDataModel? actual, Software expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.DeveloperId, Is.EqualTo(expected.DeveloperId));
                Assert.That(actual.SoftwareName, Is.EqualTo(expected.SoftwareName));
                Assert.That(actual.SoftwareType, Is.EqualTo(expected.SoftwareType));
                Assert.That(actual.Price, Is.EqualTo(expected.Price));
                Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
            });
        }

        private static SoftwareDataModel CreateModel(string id, string DeveloperId, string SoftwareName = "test", SoftwareType SoftwareType = SoftwareType.OperatingSystem, double price = 1, bool isDeleted = false)
            => new(id, SoftwareName, SoftwareType, DeveloperId, price, isDeleted);

        private Software? GetSoftwareFromDatabaseById(string id) => MiniSoftDbContext.Softwares.FirstOrDefault(x => x.Id == id);

        private static void AssertElement(Software? actual, SoftwareDataModel expected)
        {
            Assert.That(actual, Is.Not.Null);
            Assert.Multiple(() =>
            {
                Assert.That(actual.Id, Is.EqualTo(expected.Id));
                Assert.That(actual.DeveloperId, Is.EqualTo(expected.DeveloperId));
                Assert.That(actual.SoftwareName, Is.EqualTo(expected.SoftwareName));
                Assert.That(actual.SoftwareType, Is.EqualTo(expected.SoftwareType));
                Assert.That(actual.Price, Is.EqualTo(expected.Price));
                Assert.That(actual.IsDeleted, Is.EqualTo(expected.IsDeleted));
            });
        }
    }
}