qliberace/Tests/qdr.app.qlbrc.base.Tests/Services/TenantServiceTest.cs

using qdr.fnd.core.test;
using Quadarax.Application.QLiberace.Base.Dtos;
using Quadarax.Application.QLiberace.Base.Mapper;
using Quadarax.Application.QLiberace.Base.Repositories;
using Quadarax.Application.QLiberace.Base.Services;
using Quadarax.Application.QLiberace.Base.Tests.Services.Base;
using Quadarax.Application.QLiberace.Base.Tests.Services.Fakes;
using Quadarax.Application.QLiberace.Common;
using Quadarax.Application.QLiberace.Common.Domain;
using Quadarax.Foundation.Core.Data.Domain;
using Quadarax.Foundation.Core.Data.Interface.Entity;
using Quadarax.Foundation.Core.Value;

#pragma warning disable CS8625

namespace Quadarax.Application.QLiberace.Base.Tests.Services
{
    [TestFixture(Category = "Srv")]
    public class TenantServiceTest: TenantBasedService<TenantService, RepoTenant>
    {
        protected override RepoTenant GetRepository()
        {
            return new RepoTenant(Uow.As<IDataDomain>(), new QlbrcContext(null,"default", 1));
        }

        protected override TenantService GetService()
        {
            return new TenantService(GetRepository(), new ContextFake(), null);
        }

        [Test]
        public void ExistsTenantOK()
        {
            var service = GetService();

            // exists tenant
            var result = service.ExistsTenant(TenantOneCode);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Value, Is.True);

            // not exists tenant
            result = service.ExistsTenant(TenantOneCode + "x");
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Value, Is.False);
        }
        [Test]
        public void ExistsTenantFail()
        {
            var service = GetService();

            // empty tenant code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.ExistsTenant(string.Empty))
                    ?.ParamName,
                Is.EqualTo("tenantCode"));
        }
        [Test]
        public void LockOK()
        {
            var service = GetService();

            // set tenant locked
            var result = service.Lock(TenantOneCode, true);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            
            Uow.Commit();

            //verify tenant if locked
            var tenant = service.GetTenant(TenantOneCode);
            Assert.That(tenant, Is.Not.Null);
            Assert.That(tenant.IsSuccess, Is.True);
            Assert.That(tenant.Value, Is.Not.Null);
            Assert.That(tenant?.Value?.IsLocked, Is.EqualTo(true));


            // set tenant unlocked
            result = service.Lock(TenantOneCode, false);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            
            Uow.Commit();

            //verify tenant if unlocked
            tenant = service.GetTenant(TenantOneCode);
            Assert.That(tenant, Is.Not.Null);
            Assert.That(tenant.IsSuccess, Is.True);
            Assert.That(tenant.Value, Is.Not.Null);
            Assert.That(tenant?.Value?.IsLocked, Is.EqualTo(false));

        }

        [Test]
        public void LockFail()
        {
            var service = GetService();

            // empty tenant code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.Lock(string.Empty, true))
                    ?.ParamName,
                Is.EqualTo("tenantCode"));

            // invalid tenant code
            var resultTenant = service.Lock("testx", true);
            Assert.That(resultTenant, Is.Not.Null);
            Assert.That(resultTenant.IsSuccess, Is.False);
            Assert.That(resultTenant.Errors.Count(), Is.GreaterThan(0));
            Assert.That(resultTenant.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantNotFoundCode));


        }

        [Test]
        public void ValidateOK()
        {
            var service = GetService();

            // check validate unlocked
            var result = service.Validate(TenantOneCode);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);

            // set tenant locked
            var resultLock = service.Lock(TenantOneCode, true);
            Assert.That(resultLock, Is.Not.Null);
            Assert.That(resultLock.IsSuccess, Is.True);
            Uow.Commit();

            // check validate locked
            result = service.Validate(TenantOneCode);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.False);
            Assert.That(result.Errors.Count(), Is.GreaterThan(0));
            Assert.That(result.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantLockedCode));
        }

        [Test]
        public void ValidateFail()
        {
            var service = GetService();

            // empty tenant code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.Lock(string.Empty, true))
                    ?.ParamName,
                Is.EqualTo("tenantCode"));

            // invalid tenant code
            var resultTenant = service.Lock("testx", true);
            Assert.That(resultTenant, Is.Not.Null);
            Assert.That(resultTenant.IsSuccess, Is.False);
            Assert.That(resultTenant.Errors.Count(), Is.GreaterThan(0));
            Assert.That(resultTenant.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantNotFoundCode));


        }


        [Test]
        public void GetTenantOK()
        {
            var service = GetService();

            // get tenant by code
            var result = service.GetTenant(TenantOneCode);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Value, Is.Not.Null);
            Assert.That(result.Value?.Code, Is.EqualTo(TenantOneCode));
            Assert.That(result.Value?.Name, Is.EqualTo(TenantOneName));
            Assert.That(result.Value?.IsLocked, Is.EqualTo(TenantOneIsLocked));

            // get tenant by id
            result = service.GetTenant(2);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Value, Is.Not.Null);
            Assert.That(result.Value?.Code, Is.EqualTo(TenantOneCode));
            Assert.That(result.Value?.Name, Is.EqualTo(TenantOneName));
            Assert.That(result.Value?.IsLocked, Is.EqualTo(TenantOneIsLocked));
        }
        [Test]
        public void GetTenantFail()
        {
            var service = GetService();

            // empty tenant code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.GetTenant(string.Empty))
                    ?.ParamName,
                Is.EqualTo("tenantCode"));

            // get tenant by code
            var result = service.GetTenant(TenantOneCode + "X");
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.False);
            Assert.That(result.Errors.Count(), Is.GreaterThan(0));
            Assert.That(result.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantNotFoundCode));

            // get tenant by id
            result = service.GetTenant(-1);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.False);
            Assert.That(result.Errors.Count(), Is.GreaterThan(0));
            Assert.That(result.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantNotFoundCode));
        }
        [Test]
        public void CreateTenantOK()
        {
            var service = GetService();

            var newTenant = new TenantWDto()
            {
                Code = "NewTenant",
                Name = "NewTenant"
            };

            var result = service.CreateTenant(newTenant);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Value, Is.Not.Null);
            Uow.Commit();

            var tenant = service.GetTenant(newTenant.Code);
            Assert.That(tenant, Is.Not.Null);
            Assert.That(tenant.IsSuccess, Is.True);
            Assert.That(tenant.Value, Is.Not.Null);
            Assert.That(tenant.Value?.Code, Is.EqualTo(newTenant.Code));
            Assert.That(tenant.Value?.Name, Is.EqualTo(newTenant.Name));
            Assert.That(tenant.Value?.LastAccess, Is.Not.Null);

        }
        [Test]
        public void CreateTenantFail()
        {
            var service = GetService();

            // empty tenant code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.CreateTenant(null))
                    ?.ParamName,
                Is.EqualTo("tenant"));

            var newTenant = new TenantWDto()
            {
                Code = "NewTenant",
                Name = "NewTenant"
            };

            // create one tenant
            var result = service.CreateTenant(newTenant);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Value, Is.Not.Null);
            Uow.Commit();

            // create same/duplicit tenant
            result = service.CreateTenant(newTenant);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.False);
            Assert.That(result.Value, Is.Not.Null);
            Assert.That(result.Errors.Count(), Is.GreaterThan(0));
            Assert.That(result.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantAlreadyExistsCode));

            // create not valid tenant (code oveflow)
            newTenant.Code = new string('x', 21);
            result = service.CreateTenant(newTenant);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.False);
            Assert.That(result.Value, Is.Not.Null);
            Assert.That(result.Errors.Count(), Is.GreaterThan(0));
            Assert.That(result.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.ValidationErrorsCode));
        }
        [Test]
        public void UpdateTenantOK()
        {
            var service = GetService();

            // gets existing tenant
            var tenant = service.GetTenant(TenantOneCode);
            Assert.That(tenant, Is.Not.Null);
            Assert.That(tenant.IsSuccess, Is.True);
            Assert.That(tenant.Value, Is.Not.Null);

            //update some properties
            var tenantW = tenant.Value.MapDto2Dto<TenantRDto, TenantWDto>();
            Assert.That(tenantW, Is.Not.Null);
            tenantW.Name = TenantOneName + "x";
            var result = service.UpdateTenant(tenantW);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

        }
        [Test]
        public void UpdateTenantFail()
        {
            var service = GetService();

            // empty tenant code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.UpdateTenant(null))
                    ?.ParamName,
                Is.EqualTo("tenant"));

            // gets existing tenant
            var tenant = service.GetTenant(TenantOneCode);
            Assert.That(tenant, Is.Not.Null);
            Assert.That(tenant.IsSuccess, Is.True);
            Assert.That(tenant.Value, Is.Not.Null);


            //update some properties fails
            var tenantW = tenant.Value.MapDto2Dto<TenantRDto, TenantWDto>();
            Assert.That(tenantW, Is.Not.Null);
            tenantW.Name = new string('x',201);
            var result = service.UpdateTenant(tenantW);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.False);
            Assert.That(result.Errors.Count(), Is.GreaterThan(0));
            Assert.That(result.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.ValidationErrorsCode));

            //update with bad tenant code
            tenantW.Name = TenantDefaultName;
            tenantW.Code = TenantOneCode + "x";
            result = service.UpdateTenant(tenantW);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.False);
            Assert.That(result.Errors.Count(), Is.GreaterThan(0));
            Assert.That(result.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantNotFoundCode));
        }
        [Test]
        public void DeleteTenantOK()
        {
            var service = GetService();

            var result = service.GetTenant(TenantOneCode);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Value, Is.Not.Null);

            // delete tenant
            var delete = service.DeleteTenant(result.Value!.Id);
            Assert.That(delete, Is.Not.Null);
            Assert.That(delete.IsSuccess, Is.True);
            Uow.Commit();

            // verify delete
            result = service.GetTenant(TenantOneCode);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.False);
            Assert.That(result.Errors.Count(), Is.GreaterThan(0));
            Assert.That(result.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantNotFoundCode));
            
        }
        [Test]
        public void DeleteTenantFail()
        {
            var service = GetService();

            // delete tenant
            var delete = service.DeleteTenant(-1);
            Assert.That(delete, Is.Not.Null);
            Assert.That(delete.IsSuccess, Is.False);
            Assert.That(delete.Errors.Count(), Is.GreaterThan(0));
            Assert.That(delete.Errors.First().Code,
                Is.EqualTo(ExceptionLibrary.ExceptionsCodes.TenantNotFoundCode));

        }

        protected override void OnSetup()
        {
            base.OnSetup();
            var repoTenant = new RepoTenant(Uow.As<IDataDomain>(),new QlbrcContext(null, "default", 1));
            var tenant = repoTenant.New();
            tenant.Code = "default";
            tenant.Name = "Default system tenant";
            tenant.IsLocked = false;
            repoTenant.Set(tenant);
            Uow.Commit();
        }
    }
}