public async Task TestInsertOrUpdateAsync()
        {
            // Arrange
            using var uow = BeginUow();
            var modificationAuditedRepo = GetRepository <TestModificationAudited, long>();

            // Act
            var modificationAudited1 = new TestModificationAudited
            {
                Id   = 1,
                Name = "TestUpdate1"
            };
            await modificationAuditedRepo.InsertOrUpdateAsync(modificationAudited1);

            var modificationAudited4 = new TestModificationAudited
            {
                Name = "TestUpdate4"
            };
            await modificationAuditedRepo.InsertOrUpdateAsync(modificationAudited4);

            await((IUnitOfWork)uow).SaveChangesAsync();

            // Assert
            Assert.Equal(4, await modificationAuditedRepo.CountAsync());
            Assert.Equal("TestUpdate1", (await modificationAuditedRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == 1)).Name);
            Assert.Equal(1, (await modificationAuditedRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == 1)).LastModifierUserId);
            Assert.Equal("TestUpdate4", (await modificationAuditedRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == 4)).Name);
            Assert.Equal(1, (await modificationAuditedRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == 4)).CreatorUserId);

            // Complete uow
            await uow.CompleteAsync();
        }
        public void TestInsertOrUpdate()
        {
            // Arrange
            using var uow = BeginUow();
            var modificationAuditedRepo = GetRepository <TestModificationAudited, long>();

            // Act
            var modificationAudited1 = new TestModificationAudited
            {
                Id   = 1,
                Name = "TestUpdate1"
            };

            modificationAuditedRepo.InsertOrUpdate(modificationAudited1);

            var modificationAudited4 = new TestModificationAudited
            {
                Name = "TestUpdate4"
            };

            modificationAuditedRepo.InsertOrUpdate(modificationAudited4);

            ((IUnitOfWork)uow).SaveChanges();

            // Assert
            Assert.Equal(4, modificationAuditedRepo.Count());
            Assert.Equal("TestUpdate1", modificationAuditedRepo.GetAll().AsNoTracking().Single(p => p.Id == 1).Name);
            Assert.Equal(1, modificationAuditedRepo.GetAll().AsNoTracking().Single(p => p.Id == 1).LastModifierUserId);
            Assert.Equal("TestUpdate4", modificationAuditedRepo.GetAll().AsNoTracking().Single(p => p.Id == 4).Name);
            Assert.Equal(1, modificationAuditedRepo.GetAll().AsNoTracking().Single(p => p.Id == 4).CreatorUserId);

            // Complete uow
            uow.Complete();
        }
        public async Task TestUpdateAsync()
        {
            // Arrange
            using var uow = BeginUow();
            var userRepo = GetRepository <User, long>();
            var modificationAuditedRepo = GetRepository <TestModificationAudited, long>();

            #region Get then update

            // Act
            var user1 = await userRepo.GetAsync(1);

            user1.Name = "TestUser1";
            await userRepo.UpdateAsync(user1);

            var modificationAudited1 = await modificationAuditedRepo.GetAsync(1);

            modificationAudited1.Name = "TestUpdate1";
            await modificationAuditedRepo.UpdateAsync(modificationAudited1);

            await((IUnitOfWork)uow).SaveChangesAsync();

            // Assert
            Assert.Equal("TestUser1", (await userRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == user1.Id)).Name);

            Assert.Equal(1, (await modificationAuditedRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == modificationAudited1.Id)).LastModifierUserId);

            #endregion

            #region Attach

            // Act
            var user2 = new User
            {
                Id     = 2,
                Name   = "TestUser2",
                RoleId = 1
            };
            await userRepo.UpdateAsync(user2);

            var modificationAudited2 = new TestModificationAudited
            {
                Id   = 2,
                Name = "TestUpdate2"
            };
            modificationAudited2.Name = "TestUpdate2";
            await modificationAuditedRepo.UpdateAsync(modificationAudited2);

            await((IUnitOfWork)uow).SaveChangesAsync();

            // Assert
            Assert.Equal("TestUser2", (await userRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == user2.Id)).Name);

            Assert.Equal(1, (await modificationAuditedRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == modificationAudited2.Id)).LastModifierUserId);

            #endregion

            #region Update with action

            // Act
            await userRepo.UpdateAsync(3, user =>
            {
                user.Name = "TestUser3";
                return(Task.CompletedTask);
            });

            await modificationAuditedRepo.UpdateAsync(3, audited =>
            {
                audited.Name = "TestUpdate3";

                return(Task.CompletedTask);
            });

            await((IUnitOfWork)uow).SaveChangesAsync();

            // Assert
            Assert.Equal("TestUser3", (await userRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == 3)).Name);

            Assert.Equal(1, (await modificationAuditedRepo.GetAll().AsNoTracking().SingleAsync(p => p.Id == 3)).LastModifierUserId);

            #endregion

            // Complete uow
            await uow.CompleteAsync();
        }
        public void TestUpdate()
        {
            // Arrange
            using var uow = BeginUow();
            var userRepo = GetRepository <User, long>();
            var modificationAuditedRepo = GetRepository <TestModificationAudited, long>();

            #region Get then update

            // Act
            var user1 = userRepo.Get(1);
            user1.Name = "TestUser1";
            userRepo.Update(user1);

            var modificationAudited1 = modificationAuditedRepo.Get(1);
            modificationAudited1.Name = "TestUpdate1";
            modificationAuditedRepo.Update(modificationAudited1);

            ((IUnitOfWork)uow).SaveChanges();

            // Assert
            Assert.Equal("TestUser1", userRepo.GetAll().AsNoTracking().Single(p => p.Id == user1.Id).Name);

            Assert.Equal(1, modificationAuditedRepo.GetAll().AsNoTracking().Single(p => p.Id == modificationAudited1.Id).LastModifierUserId);

            #endregion

            #region Attach

            // Act
            var user2 = new User
            {
                Id     = 2,
                Name   = "TestUser2",
                RoleId = 1
            };
            userRepo.Update(user2);

            var modificationAudited2 = new TestModificationAudited
            {
                Id   = 2,
                Name = "TestUpdate2"
            };
            modificationAudited2.Name = "TestUpdate2";
            modificationAuditedRepo.Update(modificationAudited2);

            ((IUnitOfWork)uow).SaveChanges();

            // Assert
            Assert.Equal("TestUser2", userRepo.GetAll().AsNoTracking().Single(p => p.Id == user2.Id).Name);

            Assert.Equal(1, modificationAuditedRepo.GetAll().AsNoTracking().Single(p => p.Id == modificationAudited2.Id).LastModifierUserId);

            #endregion

            #region Update with action

            // Act
            userRepo.Update(3, user =>
            {
                user.Name = "TestUser3";
            });

            modificationAuditedRepo.Update(3, user =>
            {
                user.Name = "TestUpdate3";
            });

            ((IUnitOfWork)uow).SaveChanges();

            // Assert
            Assert.Equal("TestUser3", userRepo.GetAll().AsNoTracking().Single(p => p.Id == 3).Name);

            Assert.Equal(1, modificationAuditedRepo.GetAll().AsNoTracking().Single(p => p.Id == 3).LastModifierUserId);

            #endregion

            // Complete uow
            uow.Complete();
        }