public void ShouldNotCallHandleIfPostNotExist()
        {
            dbSetPost.Setup(x => x.FindAsync(id)).Returns(null);
            context.Setup(x => x.Posts).Returns(dbSetPost.Object);

            UnpinPostCommandHandler unpinPostCommandHandler = new UnpinPostCommandHandler(context.Object, stringLocalizer.Object);
            UnpinPostCommand        unpinPostCommand        = new UnpinPostCommand(id);

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

            act.Should().Throw <NotFoundException>();
        }
Exemple #2
0
        public void ShouldThrowNotFoundException()
        {
            //arrange
            var pinCommand = new UnpinPostCommand()
            {
                Id = Guid.NewGuid()
            };

            //assert
            FluentActions.Invoking(() =>
                                   SendAsync(pinCommand)).Should().ThrowAsync <NotFoundException>();
        }
        public void ShouldNotCallHandleIfNotSavedChanges()
        {
            dbSetPost.Setup(x => x.FindAsync(id)).Returns(new ValueTask <Post>(Task.FromResult(post)));
            context.Setup(x => x.Posts).Returns(dbSetPost.Object);
            context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(0));

            UnpinPostCommandHandler unpinPostCommandHandler = new UnpinPostCommandHandler(context.Object, stringLocalizer.Object);
            UnpinPostCommand        unpinPostCommand        = new UnpinPostCommand(id);

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

            act.Should().Throw <RestException>();
        }
        public async Task ShouldCallHandle()
        {
            dbSetPost.Setup(x => x.FindAsync(id)).Returns(new ValueTask <Post>(Task.FromResult(post)));
            context.Setup(x => x.Posts).Returns(dbSetPost.Object);
            context.Setup(x => x.SaveChangesAsync(It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));

            UnpinPostCommandHandler unpinPostCommandHandler = new UnpinPostCommandHandler(context.Object, stringLocalizer.Object);
            UnpinPostCommand        unpinPostCommand        = new UnpinPostCommand(id);

            var result = await unpinPostCommandHandler.Handle(unpinPostCommand, new CancellationToken());

            result.Should().Be(Unit.Value);
            post.IsPinned.Should().BeFalse();
        }
Exemple #5
0
        public async Task ShouldUnpinPost()
        {
            //arrange
            var loggedUser = await RunAsUserAsync("scott101@localhost", "Pa$$w0rd!");

            var discussionToAdd = new Faker <Discussion>("en")
                                  .RuleFor(p => p.Id, f => f.Random.Guid())
                                  .RuleFor(p => p.Title, f => f.Lorem.Sentence(wordCount: 3))
                                  .RuleFor(p => p.Description, f => f.Lorem.Sentences(sentenceCount: 2)).Generate();

            await AddAsync(discussionToAdd);

            var postToAdd = new Faker <Post>("en")
                            .RuleFor(p => p.Id, f => f.Random.Guid())
                            .RuleFor(p => p.Body, f => f.Lorem.Sentences(5))
                            .RuleFor(p => p.DiscussionId, f => discussionToAdd.Id).Generate();

            await AddAsync(postToAdd);

            var pinCommand = new PinPostCommand()
            {
                Id = postToAdd.Id
            };

            await SendAsync(pinCommand);

            var unpinCommand = new UnpinPostCommand()
            {
                Id = postToAdd.Id
            };

            //act
            await SendAsync(unpinCommand);

            var unpinnedPost = await FindByGuidAsync <Post>(postToAdd.Id);

            //assert
            unpinnedPost.Should().NotBeNull();
            unpinnedPost.IsPinned.Should().Be(false);
            unpinnedPost.LastModified.Should().BeCloseTo(DateTime.UtcNow, new TimeSpan(0, 0, 1));
            unpinnedPost.LastModifiedBy.Should().Be(loggedUser);
        }
Exemple #6
0
        public async Task ShouldThrowRestExceptionWhenPostIsAlreadyUnpinned()
        {
            //arrange
            var loggedUser = await RunAsUserAsync("scott101@localhost", "Pa$$w0rd!");

            var discussionToAdd = new Faker <Discussion>("en")
                                  .RuleFor(p => p.Id, f => f.Random.Guid())
                                  .RuleFor(p => p.Title, f => f.Lorem.Sentence(wordCount: 3))
                                  .RuleFor(p => p.Description, f => f.Lorem.Sentences(sentenceCount: 2)).Generate();

            await AddAsync(discussionToAdd);

            var postToAdd = new Faker <Post>("en")
                            .RuleFor(p => p.Id, f => f.Random.Guid())
                            .RuleFor(p => p.Body, f => f.Lorem.Sentences(5))
                            .RuleFor(p => p.DiscussionId, f => discussionToAdd.Id).Generate();

            await AddAsync(postToAdd);

            var pinCommand = new PinPostCommand()
            {
                Id = postToAdd.Id
            };

            await SendAsync(pinCommand);

            var unpinCommand = new UnpinPostCommand()
            {
                Id = postToAdd.Id
            };

            await SendAsync(unpinCommand);

            //act

            //assert
            FluentActions.Invoking(() =>
                                   SendAsync(unpinCommand)).Should().ThrowAsync <RestException>();
        }