public async void Delta_DeltaRequestNotProvided_Throws_ArgumentNullException()
        {
            var crudService = new Mock <ICrudService <Guid, TestEntity> >().Object;
            var service     = new HistoricalCrudServiceBase <Guid, TestEntity>(crudService, null, null, null, null);

            await Assert.ThrowsAsync <ArgumentNullException>(() => service.Delta(_entity.Id, null));
        }
        public async void RestoreFromChangeset_ThrowsEntityNotFoundException()
        {
            var repository  = new Mock <ICrudRepository>();
            var crudService = new Mock <ICrudService <Guid, TestEntity> >();
            var service     = new HistoricalCrudServiceBase <Guid, TestEntity>(crudService.Object, repository.Object, null, null, null);

            await Assert.ThrowsAsync <EntityNotFoundException>(() => service.RestoreFromChangeset(_entity.Id, _changeset.Id));
        }
        public void Constructor_SetAutoCommitToFalse()
        {
            var crudServiceMock = new Mock <ICrudService <Guid, TestEntity> >();
            var crudService     = crudServiceMock.Object;
            var service         = new HistoricalCrudServiceBase <Guid, TestEntity>(crudService, null, null, null, null);

            Assert.False(service.AutoCommit);
            Assert.False(crudService.AutoCommit);
        }
        public async void RestoreFromChangeset_ThrowsChangesetNotFoundException()
        {
            var repository = new Mock <ICrudRepository>();

            repository.Setup(_ => _.GetByIdAsync <Guid, TestEntity>(It.IsAny <Guid>())).ReturnsAsync(_entity);
            var crudService = new Mock <ICrudService <Guid, TestEntity> >();
            var service     = new HistoricalCrudServiceBase <Guid, TestEntity>(crudService.Object, repository.Object, null, null, null);

            await Assert.ThrowsAsync <ChangesetNotFoundException>(() => service.RestoreFromChangeset(_entity.Id, _changeset.Id));
        }
        public async void GetDeltaSnapshot_NoHistory_Throws_NoHistoryException()
        {
            var repository = new Mock <ICrudRepository>();

            repository.Setup(_ => _.GetAll <Guid, HistoricalEvent>()).Returns(_events);
            var crudService = new Mock <ICrudService <Guid, TestEntity> >();
            var service     = new HistoricalCrudServiceBase <Guid, TestEntity>(crudService.Object, repository.Object, null, null, null);

            await Assert.ThrowsAsync <NoHistoryException>(() => service.GetDeltaSnapshot(_entity.Id, DateTime.MinValue, DateTime.MaxValue));
        }
        public async void RestoreFromChangeset_ReturnsOk()
        {
            var repository = new Mock <ICrudRepository>();

            repository.Setup(_ => _.GetByIdAsync <Guid, TestEntity>(It.IsAny <Guid>())).ReturnsAsync(_entity);
            repository.Setup(_ => _.GetByIdAsync <Guid, HistoricalChangeset>(It.IsAny <Guid>())).ReturnsAsync(_changeset);
            var crudService = new Mock <ICrudService <Guid, TestEntity> >();

            crudService.Setup(_ => _.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(_entity);
            crudService.Setup(_ => _.UpdateAsync(It.IsAny <Guid>(), It.IsAny <TestEntity>())).ReturnsAsync(_entity);
            var service = new HistoricalCrudServiceBase <Guid, TestEntity>(crudService.Object, repository.Object, null, null, null);

            await service.RestoreFromChangeset(_entity.Id, _changeset.Id);

            crudService.Verify(_ => _.UpdateAsync(It.IsAny <Guid>(), It.IsAny <TestEntity>()), Times.Once);
            repository.Verify(_ => _.CreateAsync <Guid, HistoricalEvent>(It.IsAny <HistoricalEvent>()), Times.Once);
            repository.Verify(_ => _.SaveChangesAsync(), Times.Once);
        }
        public async void Copy_ReturnsCreatedElement()
        {
            var repository = new Mock <CrudRepository>();

            repository.Setup(_ => _.CreateAsync <Guid, TestEntity>(It.IsAny <TestEntity>())).ReturnsAsync(_entity);
            var crudServiceMock = new Mock <ICrudService <Guid, TestEntity> >();

            crudServiceMock.Setup(_ => _.CopyAsync(It.IsAny <Guid>())).ReturnsAsync(new TestEntity());
            var crudService = crudServiceMock.Object;
            var service     = new HistoricalCrudServiceBase <Guid, TestEntity>(crudService, repository.Object, null, null, null);

            var result = await service.CopyAsync(_entity.Id);

            Assert.NotEqual(_entity.Id, result.Id);
            repository.Verify(_ => _.CreateAsync <Guid, HistoricalEvent>(It.IsAny <HistoricalEvent>()), Times.Once);
            crudServiceMock.Verify(_ => _.CopyAsync(It.IsAny <Guid>()), Times.Once);
            repository.Verify(_ => _.SaveChangesAsync(), Times.Once);
        }
        public async void Delta_DeltaRequestProvided_DoNotCallsGetLastTimeViewed()
        {
            var lastTimeView     = DateTime.MinValue;
            var readeableService = new Mock <IHistoricalCrudReadService <Guid, TestEntity> >();

            readeableService.Setup(_ => _.GetLastTimeViewed <TestEntity>(It.IsAny <Guid>())).Returns(lastTimeView);
            var service = new HistoricalCrudServiceBase <Guid, TestEntity>(
                new Mock <ICrudService <Guid, TestEntity> >().Object,
                null,
                null,
                null,
                null);

            await Assert.ThrowsAsync <NullReferenceException>(() => service.Delta(_entity.Id, new DeltaRequest()
            {
                From = DateTime.Now
            }));

            readeableService.Verify(_ => _.GetLastTimeViewed <TestEntity>(_entity.Id), Times.Never);
        }