public async Task AddComment_ShouldWorkCorrectly()
{
var context = WilderExperienceContextInMemoryFactory.InitializeContext();
await this.SeedData(context);
var repository = new EfDeletableEntityRepository <Comment>(context);
var service = new CommentsService(repository);
var userId = context.Users.First().Id;
var experienceId = context.Experiences.First().Id;
var expectedId = 2;
var comment = new CommentViewModel()
{
Id = expectedId,
Content = "Test comment",
UserId = userId,
ExperienceId = experienceId,
};
var commentId = await service.AddComment(comment);
Assert.True(commentId == expectedId, "Add method does not work correctly");
}
public void CallUnitOfWorkCommitMethodOnce()
{
//Arrange
var unitOfWorkMock = new Mock <IUnitOfWork>();
var service = new CommentsService
(commentRepositoryMock.Object,
this.tripRepositoryMock.Object,
this.usersServiceMock.Object,
this.identifierProviderMock.Object,
unitOfWorkMock.Object);
var mockTrip = new Mock <Trip>();
mockTrip.Setup(t => t.Comments).Returns(new List <Comment>());
var mockUser = new Mock <User>();
this.tripRepositoryMock.Setup(x => x.GetById(It.IsAny <int>())).Returns(mockTrip.Object);
this.usersServiceMock.Setup(x => x.GetCurrentUser()).Returns(mockUser.Object);
//Act
service.AddComment(ValidString, ValidString);
//Assert
unitOfWorkMock.Verify(u => u.Commit(), Times.Once);
}
public void AddToTripsComment()
{
//Arrange
var service = new CommentsService
(this.commentRepositoryMock.Object,
this.tripRepositoryMock.Object,
this.usersServiceMock.Object,
this.identifierProviderMock.Object,
this.unitOfWorkMock.Object);
var mockTrip = new Mock <Trip>();
mockTrip.Setup(t => t.Comments).Returns(new List <Comment>());
this.tripRepositoryMock.Setup(x => x.GetById(It.IsAny <int>())).Returns(mockTrip.Object);
var mockUser = new Mock <User>();
this.usersServiceMock.Setup(x => x.GetCurrentUser()).Returns(mockUser.Object);
//Act
service.AddComment(ValidString, ValidString);
//Assert
Assert.AreEqual(mockTrip.Object.Comments.Count, 1);
}
public IActionResult OnPostComment([FromRoute] int id)
{
if (!ModelState.IsValid)
{
OnGet(id);
return(Page());
}
int?gameId = null;
int?postId = null;
switch (Area)
{
case PageArea.Games:
gameId = id;
break;
case PageArea.Posts:
postId = id;
break;
default:
break;
}
_commentsService.AddComment(gameId, postId, _userManager.GetUserId(User), NewComment.Text.Replace(Environment.NewLine, "<br />"));
OnGet(id);
return(Page());
}
public async Task <IHttpActionResult> SaveComment([FromBody] Comment comment)
{
using (CommentsService commentsSvc = new CommentsService()) {
Comment commentsTask = await commentsSvc.AddComment(comment);
return(Ok(commentsTask));
}
}
private async void OnUpdateStatus(object sender, EventArgs e)
{
viewModel.VisibleLoad = true;
viewModel.LoadingMessage = "";
try
{
//ProjectInsight.Models.Tasks.Task task = new ProjectInsight.Models.Tasks.Task();
//task.Id = viewModel.SelectedTaskId;
//task.WorkPercentCompleteType_Id = viewModel.SelectedWorkPercentCompleteType.Id;
var response = TasksService.client.UpdateWorkPercentComplete(viewModel.SelectedTaskId.Value, viewModel.SelectedWorkPercentCompleteType.WorkPercentComplete.Value);
// var response = await TasksService.Save(task);
if (!response.HasErrors)
{
if (txtCommentBody.Text != null && txtCommentBody.Text.Trim() != string.Empty)
{
Comment comment = new Comment();
comment.CommentBody = txtCommentBody.Text;// "Comment Added from Mobile Application";
comment.CreatedDateTimeUTC = DateTime.UtcNow;
comment.UserCreated_Id = Common.CurrentWorkspace.UserID;
comment.ObjectId = viewModel.SelectedTaskId;
try
{
var respComment = await CommentsService.AddComment(comment);
if (respComment.HasErrors)
{
Common.Instance.ShowToastMessage(respComment.Errors[0].ErrorMessage, DoubleResources.DangerSnackBar);
}
}
catch (Exception ex)
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
}
Common.Instance.ShowToastMessage("ToDo Status updated!", DoubleResources.SuccessSnackBar);
MessagingCenter.Send(this, "ToDoStatusUpdated", viewModel.SelectedTaskId.Value);
await Navigation.PopAsync();
}
else
{
Common.Instance.ShowToastMessage(response.Errors[0].ErrorMessage, DoubleResources.DangerSnackBar);
}
}
catch (Exception ex)
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
viewModel.LoadingMessage = "";
viewModel.VisibleLoad = false;
//await Navigation.PushAsync(new TaskDetailsPage(viewModel.SelectedTaskId.Value));
}
public async void onCreateNewComment(object sender, EventArgs e)
{
var commentBody = txtCommentBody.Text;
if (commentBody == null || commentBody.Length == 0)
{
sfComment.HasError = true;
//Common.Instance.ShowToastMessage("Save failed because(s): A comment is required!", DoubleResources.DangerSnackBar);
}
else
{
//progressBar.IsRunning = true;
//loadingContent.IsVisible = true;
sfComment.HasError = false;
if (mentionedUsers.Count > 0)
{
foreach (var user in mentionedUsers)
{
commentBody = commentBody.Replace(user.Name, "@user:"******"Comment Added from Mobile Application";
comment.CreatedDateTimeUTC = DateTime.UtcNow;
comment.UserCreated_Id = Common.CurrentWorkspace.UserID;
comment.ObjectId = relatedId;
// var com = await CommentsService.Get(new Guid("3c9195e9-272a-48f5-8b9a-5029e82d2a7c"));
try
{
var response = await CommentsService.AddComment(comment);
if (!response.HasErrors)
{
txtCommentBody.Text = string.Empty;
lstComments.IsVisible = true;
AddComment.IsVisible = false;
ShowComments();
}
else
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
}
catch (Exception ex)
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
//progressBar.IsRunning = false;
//loadingContent.IsVisible = false;
}
}
public ActionResult SudmitComment(Comment comment)
{
comment.DateSubmitted = DateTime.Now;
_commentsService.AddComment(comment);
List <Comment> model = _commentsService.GetComments();
return(View("Index", model));
}
public void ThrowIfParamsAreNull(string content, string url, string message)
{
// Arrange
var service = new CommentsService();
//Act / Assert
Assert.That(() => service.AddComment(content, url),
Throws.TypeOf <ArgumentNullException>()
.With.Message.Contains(message));
}
public async void AddComment_AddInvalidComment_ReturnsThrowArgumentException()
{
var mockRepository = new Mock <ICommentsRepository>();
var commentsService = new CommentsService(mockRepository.Object);
string commentText = string.Empty;
Guid guid = Guid.NewGuid();
var result = commentsService.AddComment(guid, guid, guid, commentText);
await Assert.ThrowsAsync <ArgumentException>(async() => await result);
}
public void ThrowArgumentExceptionWithProperMessageWhenContentIsEmptyOrWhiteSpace(string content)
{
var mockedRepository = new Mock <IRepository <Comment> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var commentsService = new CommentsService(mockedRepository.Object, mockedUnitOfWork.Object);
var date = DateTime.UtcNow;
var mockedUser = new Mock <User>();
var mockedDiscussion = new Mock <Discussion>();
Assert.That(() => commentsService.AddComment(content, date, mockedUser.Object, mockedDiscussion.Object),
Throws.ArgumentException.With.Message.Contains("content"));
}
public void Register(string userName, int fimlId, int rate, string comment)
{
if (commentsService.AddComment(userName, fimlId, rate, comment))
{
Response.Write("1");
}
else
{
Response.Write("0");
}
Response.End();
}
public void ThrowArgumentNullExceptionWithProperMessageWhenDiscussionIsNull()
{
var mockedRepository = new Mock <IRepository <Comment> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var content = "test";
var commentsService = new CommentsService(mockedRepository.Object, mockedUnitOfWork.Object);
var date = DateTime.UtcNow;
var mockedUser = new Mock <User>();
Assert.That(() => commentsService.AddComment(content, date, mockedUser.Object, null),
Throws.ArgumentNullException.With.Message.Contains("discussion"));
}
public void ThrowArgumentOutOfRangeExceptionWithProperMessageWhenDateIsNotValid()
{
var mockedRepository = new Mock <IRepository <Comment> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var content = "test";
var commentsService = new CommentsService(mockedRepository.Object, mockedUnitOfWork.Object);
var date = DateTime.UtcNow.AddMinutes(-10);
var mockedUser = new Mock <User>();
var mockedDiscussion = new Mock <Discussion>();
Assert.That(() => commentsService.AddComment(content, date, mockedUser.Object, mockedDiscussion.Object),
Throws.TypeOf <ArgumentOutOfRangeException>().With.Message.Contains("date"));
}
public void CallCommentdRepositoryAddMethodWhenAllParametersAreValid()
{
var mockedRepository = new Mock <IRepository <Comment> >();
var mockedUnitOfWork = new Mock <IUnitOfWork>();
var content = "test";
var commentsService = new CommentsService(mockedRepository.Object, mockedUnitOfWork.Object);
var date = DateTime.UtcNow;
var mockedUser = new Mock <User>();
var mockedDiscussion = new Mock <Discussion>();
commentsService.AddComment(content, date, mockedUser.Object, mockedDiscussion.Object);
mockedRepository.Verify(x => x.Add(It.IsAny <Comment>()), Times.Once());
}
public CommentViewModel Post([FromBody] CommentViewModel model)
{
var user = _usersService.GetUser(User.Identity.GetUserId());
var post = _postsService.GetPost(model.PostId);
var c = new Comment
{
Added = DateTime.UtcNow,
Author = user,
Post = post,
Text = model.Text,
ParentCommentId = model.ParentCommentId
};
_service.AddComment(c);
_unitOfWork.Save();
return(new CommentViewModel(c));
}
public async void onCreateNewComment(object sender, EventArgs e)
{
var commentBody = txtCommentBody.Text;
if (commentBody == null || commentBody.Length == 0)
{
Common.Instance.ShowToastMessage("Save failed because(s): A comment is required!", DoubleResources.DangerSnackBar);
}
else
{
progressBar.IsRunning = true;
loadingContent.IsVisible = true;
Comment comment = new Comment();
comment.CommentBody = txtCommentBody.Text;// "Comment Added from Mobile Application";
comment.CreatedDateTimeUTC = DateTime.UtcNow;
comment.UserCreated_Id = Common.CurrentWorkspace.UserID;
comment.ObjectId = parentItemId; //new Guid("8680da19-ee5b-4247-b9bb-cede65136c44");
// var com = await CommentsService.Get(new Guid("3c9195e9-272a-48f5-8b9a-5029e82d2a7c"));
try
{
var response = await CommentsService.AddComment(comment);
if (!response.HasErrors)
{
Common.Instance.ShowToastMessage("Success", DoubleResources.SuccessSnackBar);
await Navigation.PopAsync();
}
else
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
}
catch (Exception ex)
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
progressBar.IsRunning = false;
loadingContent.IsVisible = false;
}
}
public void ThrowIfUserServiceGetCurrentUserReturnsNull()
{
//Arrange
var service = new CommentsService
(this.commentRepositoryMock.Object,
this.tripRepositoryMock.Object,
this.usersServiceMock.Object,
this.identifierProviderMock.Object,
this.unitOfWorkMock.Object);
var mockTrip = new Mock <Trip>();
this.tripRepositoryMock.Setup(t => t.GetById(It.IsAny <int>())).Returns(mockTrip.Object);
this.usersServiceMock.Setup(x => x.GetCurrentUser()).Returns((User)null);
//Act / Assert
Assert.That(() => service.AddComment(ValidString, ValidString),
Throws.TypeOf <ArgumentNullException>()
.With.Message.Contains("Author"));
}
public void Post([FromBody] CommentsModel newComment)
{
_commentsService.AddComment(newComment);
}
private async void OnUpdateStatus(object sender, EventArgs e)
{
viewModel.VisibleLoad = true;
viewModel.LoadingMessage = "";
try
{
Issue issue = new Issue();
issue.Id = viewModel.SelectedIssueId;
issue.IssueStatusType_Id = viewModel.SelectedStatusType?.Id;
var response = await IssuesService.client.UpdateIssueStatusAsync(issue);
if (response != null && response.HasErrors)
{
Common.Instance.ShowToastMessage(response.Errors[0].ErrorMessage, DoubleResources.DangerSnackBar);
}
}
catch (Exception ex)
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
try
{
if (SelectedUserId != viewModel.SelectedUser.Id)
{
Issue issue = new Issue();
issue.Id = viewModel.SelectedIssueId;
issue.UserAssignedTo_Id = viewModel.SelectedUser.Id;
var response = await IssuesService.client.UpdateUserAssignedToAsync(viewModel.SelectedIssueId.Value, viewModel.SelectedUser.Id);
if (response != null && response.HasErrors)
{
Common.Instance.ShowToastMessage(response.Errors[0].ErrorMessage, DoubleResources.DangerSnackBar);
}
}
}
catch (Exception ex)
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
try
{
if (txtCommentBody.Text != null && txtCommentBody.Text.Trim() != string.Empty)
{
Comment comment = new Comment();
comment.CommentBody = txtCommentBody.Text;// "Comment Added from Mobile Application";
comment.CreatedDateTimeUTC = DateTime.UtcNow;
comment.UserCreated_Id = Common.CurrentWorkspace.UserID;
comment.ObjectId = viewModel.SelectedIssueId;
try
{
var respComment = await CommentsService.AddComment(comment);
if (respComment.HasErrors)
{
Common.Instance.ShowToastMessage(respComment.Errors[0].ErrorMessage, DoubleResources.DangerSnackBar);
}
}
catch (Exception ex)
{
Common.Instance.ShowToastMessage("Error communication with server!", DoubleResources.DangerSnackBar);
}
}
}
catch (Exception ex)
{
}
Common.RefreshWorkList = true;
Common.Instance.ShowToastMessage("Issue Status updated!", DoubleResources.SuccessSnackBar);
MessagingCenter.Send(this, "IssueStatusUpdated", viewModel.SelectedIssueId.Value);
await Navigation.PopAsync();
viewModel.LoadingMessage = "";
viewModel.VisibleLoad = false;
//await Navigation.PushAsync(new TaskDetailsPage(viewModel.SelectedTaskId.Value));
}
