public void ShouldNotCallHandleIfNotSavedChanges()
        {
            context.Setup(x => x.Tags).Returns(dbSetTag.Object);
            context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(0));

            CreateTagCommandHandler createTagCommandHandler = new CreateTagCommandHandler(context.Object, stringLocalizer.Object, mapper.Object);
            CreateTagCommand        createTagCommand        = new CreateTagCommand();

            mapper.Setup(x => x.Map <Tag>(createTagCommand)).Returns(new Tag());

            Func <Task> act = async() => await createTagCommandHandler.Handle(createTagCommand, new CancellationToken());

            act.Should().Throw <RestException>();
        }
        public void GivenValidRequest_ShouldCreateCorrectTagEntity()
        {
            // Arrange
            var sut        = new CreateTagCommandHandler(_context);
            var newTagName = "New Tag 1";

            // Act
            var result = sut.Handle(new CreateTagCommand {
                Name = newTagName
            }, CancellationToken.None);
            var entity = _context.Tags.FirstOrDefault(x => x.Name.Equals(newTagName));

            // Assert
            Assert.IsType <Unit>(result.Result);
            Assert.True(entity.Id > 0);
            Assert.Equal("new-tag-1", entity.Slug);
            Assert.Empty(entity.PostTags);
            Assert.True(entity.Created < DateTime.UtcNow);
        }
Example #3
0
        public async Task ShouldGetModelForValidInformation()
        {
            var createTag = new CreateTagCommand
            {
                TenantId        = _tenantId,
                CreatedBy       = _adminUserId,
                CreateTagModels = new List <CreateTagCommandModel>
                {
                    new CreateTagCommandModel
                    {
                        Name = "tag1"
                    }
                }
            };

            var tagModel = await _createTagCommandHandler.Handle(createTag, CancellationToken.None);

            Assert.Null(tagModel.Errors);
        }
        public async Task ShouldCallHandle()
        {
            var id     = new Guid();
            var tagDto = new TagCreateOrEditDto {
                Id = id
            };
            var tag = new Tag {
                Id = id
            };

            context.Setup(x => x.Tags).Returns(dbSetTag.Object);
            context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));

            CreateTagCommandHandler createTagCommandHandler = new CreateTagCommandHandler(context.Object, stringLocalizer.Object, mapper.Object);
            CreateTagCommand        createTagCommand        = new CreateTagCommand(tagDto);

            mapper.Setup(x => x.Map <Tag>(createTagCommand)).Returns(tag);

            var result = await createTagCommandHandler.Handle(createTagCommand, new CancellationToken());

            result.Should().Be(id);
        }