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

using System.Globalization;
using qdr.fnd.core.test;
using Quadarax.Application.QLiberace.Base.Repositories;
using Quadarax.Application.QLiberace.Base.Services;
using Quadarax.Application.QLiberace.Base.Tests.Services.Fakes;
using Quadarax.Application.QLiberace.Common;
using Quadarax.Foundation.Core.Data;
using Quadarax.Foundation.Core.Data.Domain;
using Quadarax.Foundation.Core.Value.Extensions;

namespace Quadarax.Application.QLiberace.Base.Tests.Services
{
    [TestFixture(Category = "Srv")]
    public class SettingsServiceTest : ServiceDbContextTest<SettingsService, RepoSetting,  BaseInMemoryDbContext>
    {
        
        protected override RepoSetting GetRepository()
        {
            return new RepoSetting(Uow.As<IDataDomain>());
        }

        protected override SettingsService GetService()
        {
            return new SettingsService(GetRepository(), null, new LoggerFactoryFake());
        }


        [Test]
        public void CreateSettingsOK()
        {
            var service = GetService();
            var settings = new ModuleSettingFake();
            var result =  service.CreateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));
            
            //check if stored in database
            Uow.Commit();
            var repo = GetRepository();
            var value = repo.Get("test", nameof(settings.PropertyString1));
            Assert.That(value, Is.Not.Null);
            Assert.That(value.Value, Is.EqualTo(settings.PropertyString1));
            Assert.That(value.IsEnabled, Is.True);
            Assert.That(value.ValueTypeQualified, Is.EqualTo(typeof(string).FullName));

        }

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

            // no module attribute
            var settings = new ModuleSettingWoAttributeFake();
            var result =  service.CreateSettings<ModuleSettingWoAttributeFake>(settings);
            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().Message.StartsWith("ModuleAttribute"), Is.True);
        }

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

            var settings = new ModuleSettingFake();
            settings.PropertyString2 = DateTime.Now.ToOADate().ToString(CultureInfo.InvariantCulture);
            var result =  service.CreateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();

            // gets the settings as dto
            var resultSettings = service.GetSettings<ModuleSettingFake>("test");
            Assert.That(resultSettings, Is.Not.Null);
            Assert.That(resultSettings.IsSuccess, Is.True);
            Assert.That(resultSettings.Errors.Count(), Is.EqualTo(0));
            Assert.That(resultSettings.Value, Is.Not.Null);
            Assert.That(resultSettings.Value.PropertyString2, Is.EquivalentTo(settings.PropertyString2));


        }

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

            // invalid module code
            var resultSettings = service.GetSettings<ModuleSettingFake>("testx");
            Assert.That(resultSettings, Is.Not.Null);
            Assert.That(resultSettings.IsSuccess, Is.False);
            Assert.That(resultSettings.Errors.Count(), Is.GreaterThan(0));
            Assert.That(resultSettings.Errors.First().Code, Is.EqualTo(ExceptionLibrary.ExceptionsCodes.SettingsNotFoundForModuleCode));

            // empty module code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.GetSettings<ModuleSettingFake>(string.Empty))
                    ?.ParamName,
                    Is.EqualTo("moduleCode"));
        }

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

            // create one settings
            var settings = new ModuleSettingFake();
            settings.PropertyString2 = DateTime.Now.ToOADate().ToString(CultureInfo.InvariantCulture);
            var result =  service.CreateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();

            var settingGot = service.GetSettingsValues("test", Paging.NoPaging());
            Assert.That(settingGot, Is.Not.Null);
            Assert.That(settingGot.IsSuccess, Is.True);
            Assert.That(settingGot.Errors.Count(), Is.EqualTo(0));
            Assert.That(settingGot.Values.Count, Is.EqualTo(8));
            Assert.That(((DateTime?)settingGot.Values["PropertyDateTimeNow"])?.ToFileShortDateTimeString(), Is.EqualTo(settings.PropertyDateTimeNow?.ToFileShortDateTimeString()));
        }

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

            // empty module code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.GetSettingsValues(string.Empty, Paging.NoPaging()))
                    ?.ParamName,
                Is.EqualTo("moduleCode"));

            // not existing module
            var settings = service.GetSettingsValues("testx", Paging.NoPaging());
            Assert.That(settings, Is.Not.Null);
            Assert.That(settings.IsSuccess, Is.True);
            Assert.That(settings.Errors.Count(), Is.EqualTo(0));
            Assert.That(settings.Values.Count, Is.EqualTo(0));

        }


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

            
            // create one settings
            var settings = new ModuleSettingFake();
            settings.PropertyString2 = DateTime.Now.ToOADate().ToString(CultureInfo.InvariantCulture);
            var result =  service.CreateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();

            var value =  service.GetSettingsValue<DateTime?>("test","PropertyDateTimeNow");
            Assert.That(value, Is.Not.Null);
            Assert.That(value.IsSuccess, Is.True);
            Assert.That(value.Errors.Count(), Is.EqualTo(0));  
            Assert.That(((DateTime?)value.Value)?.ToFileShortDateTimeString(), Is.EqualTo(settings.PropertyDateTimeNow?.ToFileShortDateTimeString()));
        }

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

            
            // create one settings
            var settings = new ModuleSettingFake();
            settings.PropertyString2 = DateTime.Now.ToOADate().ToString(CultureInfo.InvariantCulture);
            var result =  service.CreateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();

            // empty module code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.GetSettingsValue<DateTime?>(string.Empty, "PropertyDateTimeNow"))
                    ?.ParamName,
                Is.EqualTo("moduleCode"));

            // not empty value code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.GetSettingsValue<DateTime?>("test", string.Empty))
                    ?.ParamName,
                Is.EqualTo("valueCode"));

            // not existing value code
            var fail = service.GetSettingsValue<DateTime?>("test", "PropertyDateTimeNow2");
            Assert.That(fail, Is.Not.Null);
            Assert.That(fail.IsSuccess, Is.False);
            Assert.That(fail.Errors.Count(), Is.EqualTo(1));
            Assert.That(fail.Errors.First().Code, Is.EqualTo(ExceptionLibrary.ExceptionsCodes.SettingsNotFoundCode));

        }

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

            // add new value
            var result = service.AddSettingsValue<string>("test", "foo", "this is a foo", "value");
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();

            // read new created value
            var resultValue = service.GetSettingsValue<string>("test", "foo");
            Assert.That(resultValue, Is.Not.Null);
            Assert.That(resultValue.IsSuccess, Is.True);
            Assert.That(resultValue.Errors.Count(), Is.EqualTo(0));
            Assert.That(resultValue.Value, Is.EqualTo("value"));
        }

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

            // add new value correct
            var result = service.AddSettingsValue<string>("test", "foo", "this is a foo", "value");
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();

            // add duplicit value
            var fail = service.AddSettingsValue<string>("test", "foo", "this is a foo", "value");
            Assert.That(fail, Is.Not.Null);
            Assert.That(fail.IsSuccess, Is.False);
            Assert.That(fail.Errors.Count(), Is.EqualTo(1));
            Assert.That(fail.Errors.First().Code, Is.EqualTo(ExceptionLibrary.ExceptionsCodes.SettingsAlreadyExistsCode));

            // empty module code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.AddSettingsValue<string>(string.Empty, "foo", "this is a foo", "value"))
                    ?.ParamName,
                Is.EqualTo("moduleCode"));

            // not empty value code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.AddSettingsValue<string>("test", string.Empty, "this is a foo", "value"))
                    ?.ParamName,
                Is.EqualTo("valueCode"));

        }

        [Test]
        public void UpdateSettingsOK()
        {
            var service = GetService();
            
            // create one settings
            var settings = new ModuleSettingFake();
            settings.PropertyString2 = DateTime.Now.ToOADate().ToString(CultureInfo.InvariantCulture);
            var result =  service.CreateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();

            settings.PropertyBool = !settings.PropertyBool;
            settings.PropertyDateTime1 = DateTime.Now;
            settings.PropertyDateTime2 = DateTime.Now;
            settings.PropertyInt = null;

            result = service.UpdateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();
            var settingGot = service.GetSettings<ModuleSettingFake>("test");
            Assert.That(settingGot, Is.Not.Null);
            Assert.That(settingGot.IsSuccess, Is.True);
            Assert.That(settingGot.Errors.Count(), Is.EqualTo(0));
            Assert.That(settingGot.Value.PropertyDateTimeNow?.ToFileShortDateTimeString(), Is.EqualTo(settings.PropertyDateTimeNow?.ToFileShortDateTimeString()));
            Assert.That(settingGot.Value.PropertyDateTime1.ToFileShortDateTimeString(), Is.EqualTo(settings.PropertyDateTime1.ToFileShortDateTimeString()));



        }

        [Test]
        public void UpdateSettingsFail()
        {
            var service = GetService();
            
            // create one settings
            var settings = new ModuleSettingFake();
            
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.UpdateSettings<ModuleSettingFake>(null))?.ParamName,
                Is.EqualTo("settings"));

            var fail = service.UpdateSettings<ModuleSettingFake>(settings);
            Assert.That(fail, Is.Not.Null);
            Assert.That(fail.IsSuccess, Is.False);
            Assert.That(fail.Errors.Count(), Is.EqualTo(1));
            Assert.That(fail.Errors.First().Code, Is.EqualTo(ExceptionLibrary.ExceptionsCodes.SettingsNotFoundForModuleCode));

            // include test for attributes
            //Assert.That(Assert.Throws<InvalidOperationException>(() =>
            //        service.UpdateSettings<ModuleSettingWoAttributeFake>(new ModuleSettingWoAttributeFake()))?.Message.StartsWith("ModuleAttribute"),
            //    Is.True);
            

        }

        [Test]
        public void UpdateSettingsValueOK()
        {
            var service = GetService();
            
            // create one settings
            var settings = new ModuleSettingFake();
            settings.PropertyString2 = DateTime.Now.ToOADate().ToString(CultureInfo.InvariantCulture);
            var result =  service.CreateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();
            var now = DateTime.Now;
            result = service.UpdateSettingsValue("test", "PropertyDateTime1", now);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();
            var settingGot = service.GetSettingsValue<DateTime>("test","PropertyDateTime1");
            Assert.That(settingGot, Is.Not.Null);
            Assert.That(settingGot.IsSuccess, Is.True);
            Assert.That(settingGot.Errors.Count(), Is.EqualTo(0));
            Assert.That(((DateTime)settingGot.Value).ToFileShortDateTimeString(), Is.EqualTo(now.ToFileShortDateTimeString()));

            result = service.UpdateSettingsValue("test", "PropertyInt", null);

        }

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

            // add duplicit value
            var fail = service.UpdateSettingsValue("test", "foo", "value");
            Assert.That(fail, Is.Not.Null);
            Assert.That(fail.IsSuccess, Is.False);
            Assert.That(fail.Errors.Count(), Is.EqualTo(1));
            Assert.That(fail.Errors.First().Code, Is.EqualTo(ExceptionLibrary.ExceptionsCodes.SettingsNotFoundCode));

            // empty module code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.UpdateSettingsValue(string.Empty, "foo", "value"))
                    ?.ParamName,
                Is.EqualTo("moduleCode"));

            // not empty value code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.UpdateSettingsValue("test", string.Empty, "value"))
                    ?.ParamName,
                Is.EqualTo("valueCode"));

        }

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

            var now = DateTime.Now;
            var result = service.AddOrUpdateSettingsValue<DateTime>("test", "PropertyDateTime1", now);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();
            var settingGot = service.GetSettingsValue<DateTime>("test","PropertyDateTime1");
            Assert.That(settingGot, Is.Not.Null);
            Assert.That(settingGot.IsSuccess, Is.True);
            Assert.That(settingGot.Errors.Count(), Is.EqualTo(0));
            Assert.That(((DateTime)settingGot.Value).ToFileShortDateTimeString(), Is.EqualTo(now.ToFileShortDateTimeString()));

            now = DateTime.Now.AddHours(1);
            result = service.AddOrUpdateSettingsValue<DateTime>("test", "PropertyDateTime1", now);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));
            Uow.Commit();

            settingGot = service.GetSettingsValue<DateTime>("test","PropertyDateTime1");
            Assert.That(settingGot, Is.Not.Null);
            Assert.That(settingGot.IsSuccess, Is.True);
            Assert.That(settingGot.Errors.Count(), Is.EqualTo(0));
            Assert.That(((DateTime)settingGot.Value).ToFileShortDateTimeString(), Is.EqualTo(now.ToFileShortDateTimeString()));

        }

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

            
            // empty module code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.AddOrUpdateSettingsValue<DateTime>(string.Empty, "foo", "value"))
                    ?.ParamName,
                Is.EqualTo("moduleCode"));

            // not empty value code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.AddOrUpdateSettingsValue<DateTime>("test", string.Empty, "value"))
                    ?.ParamName,
                Is.EqualTo("valueCode"));
        }

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

            // create one settings
            var settings = new ModuleSettingFake();
            var result =  service.CreateSettings<ModuleSettingFake>(settings);
            Assert.That(result, Is.Not.Null);
            Assert.That(result.IsSuccess, Is.True);
            Assert.That(result.Errors.Count(), Is.EqualTo(0));

            Uow.Commit();

            var settingGot = service.GetSettingsValues("test", Paging.NoPaging());
            Assert.That(settingGot, Is.Not.Null);
            Assert.That(settingGot.IsSuccess, Is.True);
            Assert.That(settingGot.Errors.Count(), Is.EqualTo(0));
            Assert.That(settingGot.Values.Count, Is.EqualTo(8));

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

            
            // empty module code
            Assert.That(Assert.Throws<ArgumentNullException>(() =>
                        service.GetSettingsValues(string.Empty, null))
                    ?.ParamName,
                Is.EqualTo("moduleCode"));

            var settingGot = service.GetSettingsValues("testx", Paging.NoPaging());
            Assert.That(settingGot, Is.Not.Null);
            Assert.That(settingGot.IsSuccess, Is.True);
            Assert.That(settingGot.Errors.Count(), Is.EqualTo(0));
            Assert.That(settingGot.Values.Count, Is.EqualTo(0));
        }

    }
}