public async Task SaveAsync_DeleteIfDtoIsDeleted()
        {
            var repoMock = MocksCreator.RepoRecurrence();
            var service  = new RecurrenceService(repoMock.Object, Mapper, _specFactoryMock.Object);

            await service.SaveAsync(new[] { new PlannedRecurrenceDto {
                                                Uid = "42", IsDeleted = true
                                            } }, null);

            repoMock.Verify(x => x.DeleteAsync("42"));
            repoMock.Verify(x => x.AnyAsync(It.IsAny <IPlannedRecurrenceSpecification>()));
            repoMock.VerifyNoOtherCalls();
        }
 private void CreateService(params TaskEntity[] values)
 {
     _repoMock            = MocksCreator.RepoTask(values);
     _loggerMock          = new Mock <ILogger <TaskService> >();
     _notifierServiceMock = new Mock <INotifierService>();
     _taskSpecMock        = MocksCreator.TaskSpec();
     _specFactoryMock     = new Mock <ISpecificationFactory>();
     _specFactoryMock.Setup(x => x.New <ITaskSpecification, TaskEntity>()).Returns(_taskSpecMock.Object);
     _service = new TaskService(
         _repoMock.Object,
         _loggerMock.Object,
         Mapper,
         _notifierServiceMock.Object,
         _specFactoryMock.Object);
 }
        public async Task SaveAsync_CheckIsUserCanEdit()
        {
            var repoMock = MocksCreator.RepoRecurrence(new PlannedRecurrenceEntity {
                UserId = "other", Uid = "1"
            });

            repoMock.Setup(x => x.AnyAsync(It.IsAny <IPlannedRecurrenceSpecification>()))
            .Returns(Task.FromResult(true));

            var service = new RecurrenceService(repoMock.Object, Mapper, _specFactoryMock.Object);

            var list   = new PlannedRecurrenceDto[] { new() { Uid = "1" } };
            var userId = "userid";

            await Assert.ThrowsAsync <ServiceException>(() => service.SaveAsync(list, userId));
        }
        public async Task SaveAsync_CreateNewIfNoSuchUid()
        {
            var repoMock = MocksCreator.RepoRecurrence();
            var service  = new RecurrenceService(repoMock.Object, Mapper, _specFactoryMock.Object);

            await service.SaveAsync(new[] { new PlannedRecurrenceDto {
                                                Uid = "42", Task = "42"
                                            } }, "userid1");

            repoMock.Verify(x => x.UpsertAsync(It.Is <PlannedRecurrenceEntity>(y =>
                                                                               y.Uid == "42" &&
                                                                               y.Task == "42" &&
                                                                               y.UserId == "userid1")));
            repoMock.Verify(x => x.AnyAsync(It.IsAny <IPlannedRecurrenceSpecification>()));
            repoMock.Verify(x => x.GetByIdAsync("42"));
            repoMock.VerifyNoOtherCalls();
        }
Example #5
0
 public BridgeImpl()
 {
     _serviceFacade = MocksCreator.GetServiceFacade();
 }