public void UpdateAnExistingPost()
{
int expectedId = 1;
var postDto = new PostBuilder()
.WithTitle("Put")
.Build();
string payload = JsonConvert.SerializeObject(postDto);
ResponseContext responseContext = new RestAssured()
.Given()
.Name(Name)
.Header("Content-Type", "application/json")
.Body(payload)
.When()
.Put($"https://jsonplaceholder.typicode.com/posts/{expectedId}")
.Then();
responseContext.TestBody(
"Verify an existing Post resource can be updated with HTTP PUT",
x =>
{
int.TryParse(x.id.ToString(), out int actualId);
Assert.AreEqual(expectedId, actualId);
return(x.id == expectedId);
});
}
public void GIVEN_Exception_WHEN_OnActionExecuted_THEN_ExceptionIsInCompoundDocument()
{
// Arrange
var transformer = new JsonApiTransformer();
var exceptionFilter = new JsonApiExceptionFilter(transformer);
var post = new PostBuilder()
.WithAuthor(PostBuilder.Asimov)
.Build();
var context = new FilterContextBuilder()
.WithException("Test exception message")
.BuildException();
// Act
exceptionFilter.OnException(context);
// Assert
var result = (ObjectResult)context.Result;
var value = (CompoundDocument)result.Value;
Assert.Equal(1, value.Errors.Count());
Assert.Equal("Test exception message", value.Errors.First().Detail);
Assert.Equal(500, value.Errors.First().Status);
}
public Post Put(int id, [FromBody] PostEntity obj)
{
Post post = PostBuilder.Build(obj);
post = this.PostRepository.Update(post, id);
return(post ?? null);
}
public void GIVEN_MultipleInclude_WHEN_ActionExecuted_THEN_AllIncludesPresent()
{
// Arrange
var post = new PostBuilder()
.WithAuthor(PostBuilder.Asimov)
.WithComment(1, "First")
.Build();
var actionFilter = GetActionFilterForTestModel();
var context = new FilterContextBuilder()
.WithResult(new ObjectResult(post))
.WithQuery("include", "authors,comments")
.BuildActionExecuted();
// Act
actionFilter.OnActionExecuted(context);
// Assert
var result = (ObjectResult)context.Result;
var document = (CompoundDocument)result.Value;
var includedAttributes = document.Included.SelectMany(x => x.Attributes).ToList();
Assert.Contains(includedAttributes, x =>
x.Key == "name" &&
x.Value.ToString() == PostBuilder.Asimov.Name);
Assert.Contains(includedAttributes, x =>
x.Key == "body" &&
x.Value.ToString() == "First");
}
public async Task PostWithOneComment_GetPostComments_ReturnOne()
{
//Assert
var commentRepository = DatabaseHelper.GetCommentRepository("Get_Comment_Controller");
var commentController = new CommentsController(commentRepository);
var postBuilder = new PostBuilder();
var commentBuilder = new CommentBuilder();
var post = postBuilder.Build();
var comment = commentBuilder.Build();
comment.PostId = post.Id;
//Act
commentRepository.Add(comment);
commentRepository.Save();
//Assert
var apiResponse = await commentController.GetComments(post.Id);
var okResponse = apiResponse as OkObjectResult;
Assert.NotNull(okResponse);
var objectResponse = okResponse.Value as List <Comment>;
Assert.Single(objectResponse);
}
public async Task <IActionResult> Create([FromBody] CreatePostRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ErrorResponse
{
Errors = ModelState.Values.SelectMany(x =>
x.Errors.Select(e => e.ErrorMessage))
}));
}
var newPost = new PostBuilder()
.WithTitle(request?.Title)
.WithContent(request?.Content)
.WithAttachments(request?.Attachments)
.WithAuthor(HttpContext.GetUserId())
.Build();
await _postService
.CreatePostAsync(newPost)
.ConfigureAwait(false);
var locationUrl = _uriService
.GetPostUri(newPost.Id.ToString());
return(Created(locationUrl, new Response <PostResponse>(
_mapper.Map <PostResponse>(newPost))));
}
public static List <Blog> aListOfBlogsAndPosts(string name = "QWERTY")
{
var result = new List <Blog>();
for (int i = 0; i < 10; i++)
{
result.Add(BlogBuilder
.aBlog()
.WithHits(i)
.WithTile(name)
.WithPosts(new List <PostBuilder>
{
PostBuilder.aPost()
.WithTitle("Post 1"),
PostBuilder.aPost()
.WithTitle("Post 2"),
PostBuilder.aPost()
.WithTitle("Post 3"),
PostBuilder.aPost()
.WithTitle("Post 4"),
PostBuilder.aPost()
.WithTitle("Post 5"),
})
.WithHits(i)
.ToRepository()
);
}
return(result);
}
public void ShouldBeCreated_NewPost_UsingBuilder()
{
var faker = new Faker("pt_BR");
var expectedPost = new
{
Id = Guid.NewGuid(),
Title = faker.Lorem.Paragraph(),
Content = faker.Lorem.Text(),
Attachments = $"{faker.Internet.Url()},{faker.Image.PicsumUrl()}",
AuthorId = _authorFake.Id,
CreatedAt = DateTime.Now.DefaultFormat(),
UpdatedAt = DateTime.Now.DefaultFormat()
};
var post = new PostBuilder()
.WithId(expectedPost.Id)
.WithTitle(expectedPost.Title)
.WithContent(expectedPost.Content)
.WithAttachments(expectedPost.Attachments)
.WithAuthor(expectedPost.AuthorId)
.Build();
expectedPost.Should().BeEquivalentTo(post,
x => x.ExcludingMissingMembers());
}
public void AppendIncludedRepresentationRecursive_RecursesWholeTree()
{
// Arrange
var source = new PostBuilder()
.WithAuthor(PostBuilder.Asimov)
.WithComment(1, "Comment One")
.WithComment(2, "Comment Two")
.Build();
var sourceList = new List <object>()
{
source
};
var config = TestModelConfigurationBuilder.BuilderForEverything.Build();
var mapping = config.GetMapping(typeof(Post));
var context = new Context(
new Uri("http://dummy:4242/posts"),
new string[] { "authors.comments" });
var transformationHelper = new TransformationHelper(config, new FakeLinkBuilder());
// Act
var result = transformationHelper.CreateIncludedRepresentations(sourceList, mapping, context);
// Assert
Assert.NotNull(result.Single(x => x.Id == "1" && x.Type == "comments"));
Assert.NotNull(result.Single(x => x.Id == "2" && x.Type == "comments"));
Assert.NotNull(result.Single(x => x.Id == "1" && x.Type == "authors"));
Assert.False(result.Any(x => x.Type == "posts"));
}
public IActionResult AddPostResult(PostModel post)
{
try
{
var claims = HttpContext.User.Claims;
post.AuthorName = claims.Where(c => c.Type == ClaimTypes.Name)
.Select(c => c.Value)
.SingleOrDefault();
var authorID = -1;
Int32.TryParse(claims.Where(c => c.Type == "AuthorID")
.Select(c => c.Value)
.SingleOrDefault(), out authorID);
post.AuthorID = authorID;
var postBuilder = new PostBuilder(post);
var postToAdd = postBuilder.build();
var postResult = _postDataAccess.AddPost(postToAdd);
ViewBag.History = "/Home";
var pmBuilder = new PostModelBuilder(postResult);
return(View("ViewSinglePost", pmBuilder.build()));
}
catch (ArgumentException e)
{
var errorMessage = new ErrorPageModel("Cannot add post.", "The post had empty properties.");
Console.WriteLine(e.ToString());
return(ShowError(errorMessage));
}
}
public void GIVEN_PostObject_WHEN_OnActionExecuted_THEN_ResponseValid()
{
// Arrange
var actionFilter = GetActionFilterForTestModel();
var post = new PostBuilder()
.WithAuthor(PostBuilder.Asimov)
.Build();
var context = new FilterContextBuilder()
.WithResult(new ObjectResult(post))
.BuildActionExecuted();
// Act
actionFilter.OnActionExecuted(context);
// Assert
var result = (ObjectResult)context.Result;
var value = (CompoundDocument)result.Value;
var resource = (SingleResource)value.Data;
Assert.Null(value.Errors);
Assert.Equal(post.Title, resource.Attributes["title"]);
Assert.Equal(post.AuthorId, resource.Attributes["authorId"]);
}
public async Task <IActionResult> DeletePostResult(PostModel post)
{
var userCanDelete = await HasDeletePowers();
if (IsUserPostAuthor(post.AuthorID) || userCanDelete)
{
try
{
var postBuilder = new PostBuilder(post);
var postResult = _postDataAccess.DeletePost(postBuilder.build());
ViewBag.History = "/Home";
return(RedirectToAction("ViewAll"));
}
catch (ArgumentException e)
{
var errorMessage = new ErrorPageModel("Invalid Post.", "We couldn't find the post.");
ViewBag.History = "/Home/ViewAll";
Console.WriteLine(e.ToString());
return(ShowError(errorMessage));
}
}
else
{
var errorMessage = new ErrorPageModel("Permission Denied.", "You do not have permission to do that.");
return(ShowError(errorMessage));
}
}
public async Task <IActionResult> EditPostResult(PostModel post)
{
var userCanEdit = await HasEditPowers();
if (IsUserPostAuthor(post.AuthorID) || userCanEdit)
{
try
{
ViewBag.History = "/Home/ViewAll";
var postBuilder = new PostBuilder(post);
var postToAdd = postBuilder.build();
var postResult = _postDataAccess.EditPost(postToAdd);
var pmBuilder = new PostModelBuilder(postResult);
return(View("ViewSinglePost", pmBuilder.build()));
}
catch (ArgumentException e)
{
ErrorPageModel errorMessage = new ErrorPageModel("Invalid Post.", "The post contained invalid input.");
Console.WriteLine(e.ToString());
return(ShowError(errorMessage));
}
}
else
{
var errorMessage = new ErrorPageModel("Permission Denied", "You do not have permission to edit this post.");
return(ShowError(errorMessage));
}
}
public async Task ShouldBeCreatedNewPost()
{
var faker = new Faker("pt_BR");
var newPost = new PostBuilder()
.WithId(Guid.NewGuid())
.WithTitle(faker.Lorem.Paragraph())
.WithContent(faker.Lorem.Text())
.WithAttachments(faker.Image.PicsumUrl())
.WithAuthor(Guid.Parse("d4182477-0823-4908-be1d-af808e594306"))
.Build();
await _postRepository.CreatePostAsync(newPost);
var cmdResult = await _inMemoryDbContext.SaveChangesAsync();
// Verifica se alguma linha foi afetada
cmdResult.Should().BeGreaterOrEqualTo(1);
var createdPost = await _postRepository.GetByIdAsync(newPost.Id);
newPost.Should().BeEquivalentTo(createdPost, options => options
.Excluding(p => p.Author)
.ExcludingMissingMembers());
createdPost.Author.FirstName.Should().Be("João");
createdPost.Author.Email.Should().Be("*****@*****.**");
createdPost.CreatedAt.Should().Be(DateTime.Now.DefaultFormat());
createdPost.UpdatedAt.Should().Be(DateTime.Now.DefaultFormat());
}
public void TimestampIsRequiredForPost()
{
var p = new PostBuilder().Build().Post;
p.Timestamp = default(DateTime);
Assert.Throws <ValidationException>(() => p.Validate());
}
public void TitleIsRequiredForPost()
{
var p = new PostBuilder().Build().Post;
p.Title = "";
Assert.Throws <ValidationException>(() => p.Validate());
}
public void CreateANewPost()
{
var postDto = new PostBuilder().Build();
string payload = JsonConvert.SerializeObject(postDto);
ResponseContext responseContext = new RestAssured()
.Given()
.Name(Name)
.Header("Content-Type", "application/json")
.Body(payload)
.When()
.Post("https://jsonplaceholder.typicode.com/posts")
.Then();
responseContext.TestBody(
"Verify a new Post resource can be created with HTTP POST by confirming the Id returned in the response",
x =>
{
int.TryParse(x.id.ToString(), out int actualId);
Assert.AreEqual(101, actualId);
return(x.id == 101);
});
responseContext.TestStatus(
"Verify a new Post resource can be created with HTTP POST by confirming the response HTTP status code",
x =>
{
Assert.AreEqual(201, x);
return(x == 201);
});
responseContext.AssertAll();
}
/// <summary>
/// Get the RedditPosts
/// </summary>
private void CreatePost()
{
var postBuilder = new PostBuilder();
var posts = postBuilder.GetPosts();
Iterator = new Iterator.Iterator(posts);
Post = Iterator.CurrentItem;
}
public void NotNullDescriptionTest()
{
var builder = new PostBuilder();
var postTest = builder
.CheckDescription("Description");
Assert.NotNull(postTest);
}
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
var postBuilder = new PostBuilder(builder.Entity <Post>());
var pageBuilder = new PageBuilder(builder.Entity <Page>());
var categoryBuilder = new CategoryBuilder(builder.Entity <Category>());
var feedbackBuilder = new FeedbackBuilder(builder.Entity <Feedback>());
var applicationUserBuilder = new ApplicationUserBuilder(builder.Entity <ApplicationUser>());
}
public ThreadBuilder WithPost(PostBuilder postBuilder)
{
if (postBuilder == null)
{
throw new ArgumentNullException(nameof(postBuilder));
}
postBuilder.InThread(_thread);
_postBuilder = postBuilder;
return(this);
}
public async Task ShouldBeReturnedFalseIfDeletedPostNotExists()
{
var notExistingPost = new PostBuilder()
.WithTitle("Post not found")
.WithContent("It's a post not exist")
.WithAttachments("err.txt,image.jpg")
.Build();
var deleted = await _postService
.DeletePostAsync(notExistingPost);
deleted.Should().BeFalse();
}
public void PostDerive()
{
var post = new PostBuilder(this.Session).Build();
this.Session.Derive();
Assert.Equal(1, post.Counter);
post.Counter = 3;
this.Session.Derive();
Assert.Equal(5, post.Counter);
}
public async Task ShouldBeCreatedPost()
{
var newPost = new PostBuilder()
.WithTitle("Post 3")
.WithContent("New post created by xunit test")
.WithAttachments("log.txt,image.jpg")
.WithAuthor(Guid.Parse("9ab3d110-71e1-418f-86eb-519146e7d702"))
.Build();
var created = await _postService.CreatePostAsync(newPost);
created.Should().BeTrue();
_dbContext.Posts.Should().HaveCount(3);
}
public void EmptyTable_AddPost_CountIsOne()
{
//Arrange
var postRepository = DatabaseHelper.GetPostRepository("Add_Post_Db");
var postBuilder = new PostBuilder();
var post = postBuilder.Build();
//Act
postRepository.Add(post);
postRepository.Save();
//Assert
Assert.Equal(1, postRepository.GetCount());
}
public void ThenPostIsNotDisplayedOnMainPage(string isDisplayed)
{
Post post = PostBuilder.GeneratePost(RegistrationService.RegisterNewUser(AccountBuilder.CreateAccount()));
PostService.AddPost(post);
if (isDisplayed != "not")
{
Assert.IsTrue(PostService.IsPostDisplayed(post));
}
else
{
Assert.IsFalse(PostService.IsPostDisplayed(post));
}
}
public static BlogBuilder aDefaultBlogWithPost()
=> BlogBuilder.aBlog().WithPosts(new List <PostBuilder>
{
PostBuilder.aPost()
.WithTitle("Post 1"),
PostBuilder.aPost()
.WithTitle("Post 2"),
PostBuilder.aPost()
.WithTitle("Post 3"),
PostBuilder.aPost()
.WithTitle("Post 4"),
PostBuilder.aPost()
.WithTitle("Post 5"),
});
private static void Main(string[] args)
{
// Main project has reference to this project
// Post build runs this executable (in same folder - only in Release)
// (1) Remove unnecessary files
// (2) Run "FilrPostBuild.exe" with parameter pointing towards build directory
// (3) Delete "ILRepack.dll"
// (4) Delete "FilrPostBuild.exe"
PostBuilder.Run(args[0], (builder) =>
{
builder.RemoveFilesWithExtensions(".pdb", ".xml", ".exe.config");
builder.Repack();
});
}
public async Task <Unit> Handle(SeedCommand request, CancellationToken cancellationToken)
{
var thread = await _dbContext.Threads.FirstOrDefaultAsync(e => e.Title == "New Thread", cancellationToken);
if (thread != null)
{
return(Unit.Value);
}
var user = await _dbContext.Users.FirstOrDefaultAsync(e => e.Username == "Admin",
cancellationToken : cancellationToken) ?? new UserBuilder()
.WithPassword(BCrypt.Net.BCrypt.EnhancedHashPassword("admin"))
.WithUsername("Admin")
.WithEmailAddress("*****@*****.**")
.WithJoinDateUtc(_dateTimeService.UtcNow)
.Build();
var subForum = await _dbContext.SubForums.FirstOrDefaultAsync(e => e.Title == "Main", cancellationToken) ??
new SubForumBuilder()
.WithName("Main")
.Build();
var generalTopic =
await _dbContext.Topics.FirstOrDefaultAsync(e => e.Title == "General", cancellationToken) ??
new TopicBuilder()
.WithName("General")
.UnderSubForum(subForum)
.Build();
var postBuilder = new PostBuilder()
.WithContent("Hello World")
.CreatedDateUtc(_dateTimeService.UtcNow)
.CreatedByUser(user);
thread = new ThreadBuilder()
.WithTitle("New Thread")
.InTopic(generalTopic)
.WithPost(postBuilder)
.CreatedBy(user)
.CreatedDate(_dateTimeService.UtcNow)
.Build();
_dbContext.Threads.Add(thread);
await _dbContext.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public void PostWithNoComments_AddComment_CountIsOne()
{
//Arrange
var commentRepository = DatabaseHelper.GetCommentRepository("Add_Post_Db");
var commentBuilder = new CommentBuilder();
var postBuilder = new PostBuilder();
var post = postBuilder.Build();
var comment = commentBuilder.Build();
comment.PostId = post.Id;
//Act
commentRepository.Add(comment);
commentRepository.Save();
//Assert
Assert.Equal(1, commentRepository.GetCount(post.Id));
}
