Exemple #1
0
        public async Task ShouldThrowRestExceptionWhenDiscussionIsAlreadyUnpinned()
        {
            //arrange
            var loggedUser = await RunAsUserAsync("scott101@localhost", "Pa$$w0rd!");

            var createdDiscussionId = await SendAsync(new Faker <CreateDiscussionCommand>("en")
                                                      .RuleFor(d => d.Id, f => f.Random.Guid())
                                                      .RuleFor(d => d.Title, f => f.Lorem.Sentence(wordCount: 3))
                                                      .RuleFor(d => d.Description, f => f.Lorem.Sentences(sentenceCount: 2))
                                                      .RuleFor(d => d.PostBody, f => f.Lorem.Paragraph()).Generate());

            var pinCommand = new PinDiscussionCommand()
            {
                Id = createdDiscussionId
            };

            await SendAsync(pinCommand);

            var unpinCommand = new UnpinDiscussionCommand()
            {
                Id = createdDiscussionId
            };

            await SendAsync(unpinCommand);

            //act

            //assert
            FluentActions.Invoking(() =>
                                   SendAsync(unpinCommand)).Should().Throw <RestException>();
        }
Exemple #2
0
        public async Task ShouldUnpinDiscussion()
        {
            //arrange
            var loggedUser = await RunAsUserAsync("scott101@localhost", "Pa$$w0rd!");

            var createdDiscussionId = await SendAsync(new Faker <CreateDiscussionCommand>("en")
                                                      .RuleFor(d => d.Id, f => f.Random.Guid())
                                                      .RuleFor(d => d.Title, f => f.Lorem.Sentence(wordCount: 3))
                                                      .RuleFor(d => d.Description, f => f.Lorem.Sentences(sentenceCount: 2))
                                                      .RuleFor(d => d.PostBody, f => f.Lorem.Paragraph()).Generate());

            var pinCommand = new PinDiscussionCommand()
            {
                Id = createdDiscussionId
            };

            await SendAsync(pinCommand);

            var unpinCommand = new UnpinDiscussionCommand()
            {
                Id = createdDiscussionId
            };

            //act
            await SendAsync(unpinCommand);

            var unpinnedDiscussion = await FindByGuidAsync <Discussion>(createdDiscussionId);

            //assert
            unpinnedDiscussion.Should().NotBeNull();
            unpinnedDiscussion.IsPinned.Should().Be(false);
            unpinnedDiscussion.LastModified.Should().BeCloseTo(DateTime.UtcNow, 1000);
            unpinnedDiscussion.LastModifiedBy.Should().Be(loggedUser);
        }
        public void ShouldNotCallHandleIfDiscussionNotExist()
        {
            dbSetDiscussion.Setup(x => x.FindAsync(id)).Returns(null);
            context.Setup(x => x.Discussions).Returns(dbSetDiscussion.Object);

            UnpinDiscussionCommandHandler unpinDiscussionCommandHandler = new UnpinDiscussionCommandHandler(context.Object, stringLocalizer.Object);
            UnpinDiscussionCommand        unpinDiscussionCommand        = new UnpinDiscussionCommand(id);

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

            act.Should().ThrowAsync <NotFoundException>();
        }
Exemple #4
0
        public void ShouldThrowNotFoundException()
        {
            //arrange
            var unpinCommand = new UnpinDiscussionCommand()
            {
                Id = Guid.NewGuid()
            };

            //assert
            FluentActions.Invoking(() =>
                                   SendAsync(unpinCommand)).Should().Throw <NotFoundException>();
        }
        public void ShouldNotCallHandleIfNotSavedChanges()
        {
            dbSetDiscussion.Setup(x => x.FindAsync(id)).Returns(new ValueTask <Discussion>(Task.FromResult(discussion)));
            context.Setup(x => x.Discussions).Returns(dbSetDiscussion.Object);
            context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(0));

            UnpinDiscussionCommandHandler unpinDiscussionCommandHandler = new UnpinDiscussionCommandHandler(context.Object, stringLocalizer.Object);
            UnpinDiscussionCommand        unpinDiscussionCommand        = new UnpinDiscussionCommand(id);

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

            act.Should().ThrowAsync <RestException>();
        }
        public async Task ShouldCallHandle()
        {
            dbSetDiscussion.Setup(x => x.FindAsync(id)).Returns(new ValueTask <Discussion>(Task.FromResult(discussion)));
            context.Setup(x => x.Discussions).Returns(dbSetDiscussion.Object);
            context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));

            UnpinDiscussionCommandHandler unpinDiscussionCommandHandler = new UnpinDiscussionCommandHandler(context.Object, stringLocalizer.Object);
            UnpinDiscussionCommand        unpinDiscussionCommand        = new UnpinDiscussionCommand(id);

            var result = await unpinDiscussionCommandHandler.Handle(unpinDiscussionCommand, new CancellationToken());

            result.Should().Be(Unit.Value);
            discussion.IsPinned.Should().BeFalse();
        }