qliberace/Common/qdr.fnd.core.test/Repositories/GeneralRepositoryTest.cs

using Microsoft.EntityFrameworkCore;
using qdr.fnd.core.test.Repositories.Fakes;
using Quadarax.Foundation.Core.Data;
using Quadarax.Foundation.Core.Data.Domain;

namespace qdr.fnd.core.test.Repositories
{

    [TestFixture(Category = "Dao")]
    public class GeneralRepositoryTest : RepositoryDbContextTest<TestRepo, TestDbContext>
    {


        private const string DaoName1 = "Name1";
        private const string DaoName2 = "Name2";
        private const string DaoValue1 = "Value1";
        private const string DaoValue2 = "Value2";


        [Test]
        public void AddEntity()
        {

            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.New();
                dao.Name = DaoName1;
                dao.Value = DaoValue1;
                uow.Commit();

                // read check inside UOW
                dao = repo.Get(1);
                Assert.IsNotNull(dao, "Cannot obtain created dao inside UOW.");
                Assert.That(dao.Name, Is.EqualTo(DaoName1));
                Assert.That(dao.Value, Is.EqualTo(DaoValue1));
            }
            // read check outside UOW
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.Get(1);
                Assert.IsNotNull(dao, "Cannot obtain created dao outside UOW.");
                Assert.That(dao.Name, Is.EqualTo(DaoName1));
                Assert.That(dao.Value, Is.EqualTo(DaoValue1));
            }
        }

        [Test]
        public void UpdateEntity()
        {
            

            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.New();
                dao.Name = DaoName1;
                dao.Value = DaoValue1;
                uow.Commit();

                dao.Value = DaoValue2;
                uow.Commit();
            }
            // read check outside UOW
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.Get(1);
                Assert.IsNotNull(dao, "Cannot obtain created dao outside UOW.");
                Assert.That(dao.Name, Is.EqualTo(DaoName1));
                Assert.That(dao.Value, Is.EqualTo(DaoValue2));
            }
        }
        [Test]
        public void RemoveEntity()
        {
            
            var result = false;
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.New();
                dao.Name = DaoName1;
                dao.Value = DaoValue1;
                uow.Commit();
                result = repo.Remove(1);
                uow.Commit();

            }
            // read check outside UOW
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.Get(1);
                Assert.IsNull(dao, "Dao doesn't remove outside UOW.");
                result = repo.Remove(1);
                Assert.IsFalse(result);
            }
        }
        [Test]
        public void QueryEntity()
        {
            var context = new TestDbContext(new DbContextOptions<TestDbContext>());
            context.Database.EnsureCreated();
            var dbcResolver = new DomainContextResolver<TestDbContext>(context);

            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.New();
                dao.Name = DaoName1;
                dao.Value = DaoValue1;
                dao = repo.New();
                dao.Name = DaoName2;
                dao.Value = DaoValue2;
                uow.Commit();
                // read check inside UOW
                var list = repo.Query(Paging.NoPaging());
                Assert.IsNotNull(list);
                Assert.That(list.Count(), Is.EqualTo(2));

            }
            // read check outside UOW
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var list = repo.Query(Paging.NoPaging());
                Assert.IsNotNull(list);
                Assert.That(list.Count(), Is.EqualTo(2));
            }
        }
        [Test]
        public void QueryPagingEntity()
        {
            
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.New();
                dao.Name = DaoName1;
                dao.Value = DaoValue1;
                dao = repo.New();
                dao.Name = DaoName2;
                dao.Value = DaoValue2;
                uow.Commit();

            }
            // read check outside UOW
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var list = repo.Query(new Paging(0,1))?.ToArray();
                Assert.IsNotNull(list);
                Assert.That(list.Count(), Is.EqualTo(1));
                Assert.That(list[0].Name, Is.EqualTo(DaoName1));
                list = repo.Query(new Paging(1,1))?.ToArray();
                Assert.IsNotNull(list);
                Assert.That(list[0].Name, Is.EqualTo(DaoName2));
            }
        }

        [Test]
        public void QueryPagingFail()
        {
            
            // read check outside UOW
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                Assert.That(Assert.Throws<ArgumentNullException>(() =>
                            repo.Query(null))
                        .ParamName,
                    Is.EqualTo("paging"));
            }
        }

        [Test]
        public void RollbackEntity()
        {
            
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.New();
                dao.Name = DaoName1;
                dao.Value = DaoValue1;
                uow.Commit();
                dao = repo.Get(1);
                Assert.IsNotNull(dao);
                Assert.That(dao.Name, Is.EqualTo(DaoName1));
                dao.Name = DaoName2;
            }
            // read check outside UOW
            using (var uow = new UnitOfWork<TestDbContext>(_dbcResolver))
            {
                var repo = new TestRepo(uow.As<IDataDomain>());
                var dao = repo.Get(1);
                Assert.IsNotNull(dao);
                Assert.That(dao.Name, Is.EqualTo(DaoName1));

            }
        }

        protected override TestRepo GetRepository()
        {
            throw new NotImplementedException();
        }
    }
}