private void GetCommentsTest(StringBuilder sb, int num)
{
sb.Append($"{num}) GetCommentsTest : ");
StepFinished?.Invoke(sb.ToString());
var limit = 3;
var testPost = GetFirstPostWhere(sb, PostType.Top, i => i.Children >= limit + limit);
if (testPost == null)
{
return;
}
var request = new NamedInfoModel(testPost.Url)
{
Limit = limit
};
var response = _api.GetComments(request, CancellationToken.None).Result;
if (IsError1(sb, limit, response, response.Result.Results.Count))
{
return;
}
request.Offset = response.Result.Results.Last().Url;
response = _api.GetComments(request, CancellationToken.None).Result;
if (IsError2(sb, limit, response, request.Offset))
{
return;
}
sb.AppendLine("pass.");
}
public async Task <OperationResult <ListResponse <Post> > > GetComments(NamedInfoModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results != null)
{
return(new OperationResult <ListResponse <Post> >(results));
}
var parameters = new Dictionary <string, object>();
AddOffsetLimitParameters(parameters, model.Offset, model.Limit);
AddLoginParameter(parameters, model.Login);
var endpoint = $"{BaseUrl}/{GatewayVersion.V1P1}/post/{model.Url}/comments";
var resp = await HttpClient.Get <ListResponse <Post> >(endpoint, parameters, token);
if (resp.IsSuccess)
{
resp.Result.Results.ForEach(p => p.IsComment = true);
}
return(resp);
}
public async Task GetPostInfo(KnownChains apiName, string url)
{
// Arrange
var request = new NamedInfoModel(url);
request.ShowNsfw = true;
request.ShowLowRated = true;
// Act
var response = await Api[apiName].GetPostInfo(request, CancellationToken.None);
// Assert
AssertResult(response);
Assert.That(response.Result.Body, Is.Not.Empty);
Assert.That(response.Result.Title, Is.Not.Empty);
Assert.That(response.Result.Url, Is.Not.Empty);
Assert.That(response.Result.Category, Is.Not.Empty);
Assert.That(response.Result.Author, Is.Not.Empty);
Assert.That(response.Result.Avatar, Is.Not.Null);
Assert.That(response.Result.AuthorRewards, Is.Not.Null);
Assert.That(response.Result.AuthorReputation, Is.Not.Null);
Assert.That(response.Result.NetVotes, Is.Not.Null);
Assert.That(response.Result.Children, Is.Not.Null);
Assert.That(response.Result.Created, Is.Not.Null);
Assert.That(response.Result.CuratorPayoutValue, Is.Not.Null);
Assert.That(response.Result.TotalPayoutValue, Is.Not.Null);
Assert.That(response.Result.PendingPayoutValue, Is.Not.Null);
Assert.That(response.Result.MaxAcceptedPayout, Is.Not.Null);
Assert.That(response.Result.TotalPayoutReward, Is.Not.Null);
Assert.That(response.Result.Vote, Is.False);
Assert.That(response.Result.Tags, Is.Not.Null);
Assert.That(response.Result.Depth, Is.Not.Null);
}
private void GetPostInfoTest(StringBuilder sb, int num)
{
sb.Append($"{num}) GetPostInfoTest : ");
StepFinished?.Invoke(sb.ToString());
var getPosts = new PostsModel(PostType.Top);
var postsResp = _api.GetPosts(getPosts, CancellationToken.None)
.Result;
if (!postsResp.IsSuccess)
{
sb.AppendLine($"fail. Reason:{Environment.NewLine} {postsResp.Error.Message}");
return;
}
if (postsResp.Result.Results.Count == 0)
{
sb.AppendLine("fail. Reason:{Environment.NewLine} There are no Posts!");
return;
}
var testPost = postsResp.Result.Results.First();
var request = new NamedInfoModel(testPost.Url);
var response = _api.GetPostInfo(request, CancellationToken.None).Result;
if (!response.IsSuccess)
{
sb.AppendLine($"fail. Reason:{Environment.NewLine} {postsResp.Error.Message}");
return;
}
sb.AppendLine("pass.");
}
public async Task Comments(KnownChains apiName, string url)
{
// Arrange
var request = new NamedInfoModel(url);
// Act
var response = await Api[apiName].GetComments(request, CancellationToken.None);
// Assert
AssertResult(response);
Assert.That(response.Result.Results.Any());
Assert.That(response.Result.Results, Is.Not.Empty);
Assert.That(response.Result.Results.First().Body, Is.Not.Empty);
Assert.That(response.Result.Results.First().Title, Is.Not.Empty);
Assert.That(response.Result.Results.First().Url, Is.Not.Empty);
Assert.That(response.Result.Results.First().Category, Is.Not.Empty);
Assert.That(response.Result.Results.First().Author, Is.Not.Empty);
Assert.That(response.Result.Results.First().Avatar, Is.Not.Null);
Assert.That(response.Result.Results.First().AuthorRewards, Is.Not.Null);
Assert.That(response.Result.Results.First().AuthorReputation, Is.Not.Null);
Assert.That(response.Result.Results.First().NetVotes, Is.Not.Null);
Assert.That(response.Result.Results.First().Children, Is.Not.Null);
Assert.That(response.Result.Results.First().Created, Is.Not.Null);
Assert.That(response.Result.Results.First().CuratorPayoutValue, Is.Not.Null);
Assert.That(response.Result.Results.First().TotalPayoutValue, Is.Not.Null);
Assert.That(response.Result.Results.First().PendingPayoutValue, Is.Not.Null);
Assert.That(response.Result.Results.First().MaxAcceptedPayout, Is.Not.Null);
Assert.That(response.Result.Results.First().TotalPayoutReward, Is.Not.Null);
Assert.That(response.Result.Results.First().Vote, Is.Not.Null);
Assert.That(response.Result.Results.First().Tags, Is.Empty);
Assert.That(response.Result.Results.First().Depth, Is.Not.Zero);
}
public async Task GetCommentsTest(KnownChains apiName, string url)
{
var request = new NamedInfoModel(url);
var result = await Gateway[apiName].GetComments(request, CancellationToken.None);
Assert.IsTrue(result.IsSuccess, result.Error?.Message);
}
public async Task CreateCommentTest(KnownChains apiName)
{
var user = Users[apiName];
// Load last created post
var userPostsRequest = new UserPostsModel(user.Login);
userPostsRequest.ShowNsfw = true;
userPostsRequest.ShowLowRated = true;
var userPostsResponse = await Api[apiName].GetUserPosts(userPostsRequest, CancellationToken.None);
AssertResult(userPostsResponse);
var lastPost = userPostsResponse.Result.Results.First();
// 2) Create new comment
// Wait for 20 seconds before commenting
Thread.Sleep(TimeSpan.FromSeconds(20));
var createCommentModel = new CreateOrEditCommentModel(user, lastPost, $"Test comment {DateTime.Now:G}", AppSettings.AppInfo);
var createCommentResponse = await Api[apiName].CreateOrEditComment(createCommentModel, CancellationToken.None);
AssertResult(createCommentResponse);
Assert.That(createCommentResponse.IsSuccess, Is.True);
// Wait for data to be writed into blockchain
Thread.Sleep(TimeSpan.FromSeconds(15));
// Load comments for this post and check them
var getCommentsRequest = new NamedInfoModel(lastPost.Url);
var commentsResponse = await Api[apiName].GetComments(getCommentsRequest, CancellationToken.None);
AssertResult(commentsResponse);
Assert.IsNotNull(commentsResponse.Result.Results.FirstOrDefault(i => i.Url.EndsWith(createCommentModel.Permlink)));
}
public async Task EditCommentTest(KnownChains apiName)
{
// Arrange
var user = Users[apiName];
var userPostsRequest = new UserPostsModel(user.Login);
userPostsRequest.ShowLowRated = true;
userPostsRequest.ShowNsfw = true;
var userPostsResponse = await Api[apiName].GetUserPosts(userPostsRequest, CancellationToken.None);
var post = userPostsResponse.Result.Results.FirstOrDefault(i => i.Children > 0);
Assert.IsNotNull(post);
var namedRequest = new NamedInfoModel(post.Url);
var comments = await Api[apiName].GetComments(namedRequest, CancellationToken.None);
var comment = comments.Result.Results.FirstOrDefault(i => i.Author.Equals(user.Login));
Assert.IsNotNull(comment);
var editCommentRequest = new CreateOrEditCommentModel(user, post, comment, comment.Body += $" edited {DateTime.Now}", AppSettings.AppInfo);
var result = await Api[apiName].CreateOrEditComment(editCommentRequest, CancellationToken.None);
AssertResult(result);
}
public async Task VoteCommentTest(KnownChains apiName)
{
var user = Users[apiName];
// Load last created post
var userPostsRequest = new UserPostsModel(user.Login)
{
ShowLowRated = true, ShowNsfw = true
};
var userPostsResponse = await Api[apiName].GetUserPosts(userPostsRequest, CancellationToken.None);
AssertResult(userPostsResponse);
var lastPost = userPostsResponse.Result.Results.First(i => i.Children > 0);
// Load comments for this post and check them
var getCommentsRequest = new NamedInfoModel(lastPost.Url);
var commentsResponse = await Api[apiName].GetComments(getCommentsRequest, CancellationToken.None);
// 5) Vote up comment
var post = commentsResponse.Result.Results.First();
var voteUpCommentRequest = new VoteModel(user, post, VoteType.Up);
var voteUpCommentResponse = await Api[apiName].Vote(voteUpCommentRequest, CancellationToken.None);
AssertResult(voteUpCommentResponse);
Assert.That(voteUpCommentResponse.Result.IsSuccess, Is.True);
Assert.That(voteUpCommentResponse.Result.NewTotalPayoutReward, Is.Not.Null);
Assert.That(voteUpCommentResponse.Result.NewTotalPayoutReward, Is.Not.Null);
// Wait for data to be writed into blockchain
Thread.Sleep(TimeSpan.FromSeconds(15));
getCommentsRequest.Login = user.Login;
var commentsResponse2 = await Api[apiName].GetComments(getCommentsRequest, CancellationToken.None);
// Check if last comment was voted
AssertResult(commentsResponse2);
var comm = commentsResponse2.Result.Results.FirstOrDefault(i => i.Url.Equals(post.Url, StringComparison.OrdinalIgnoreCase));
Assert.IsNotNull(comm);
Assert.That(comm.Vote, Is.True);
// 6) Vote down comment
var voteDownCommentRequest = new VoteModel(user, post, VoteType.Down);
var voteDownCommentResponse = await Api[apiName].Vote(voteDownCommentRequest, CancellationToken.None);
AssertResult(voteDownCommentResponse);
Assert.That(voteDownCommentResponse.Result.IsSuccess, Is.True);
Assert.That(voteDownCommentResponse.Result.NewTotalPayoutReward, Is.Not.Null);
Assert.That(voteDownCommentResponse.Result.NewTotalPayoutReward, Is.Not.Null);
// Wait for data to be writed into blockchain
Thread.Sleep(TimeSpan.FromSeconds(15));
getCommentsRequest.Login = user.Login;
var commentsResponse3 = await Api[apiName].GetComments(getCommentsRequest, CancellationToken.None);
// Check if last comment was voted
AssertResult(commentsResponse3);
comm = commentsResponse3.Result.Results.FirstOrDefault(i => i.Url.Equals(post.Url, StringComparison.OrdinalIgnoreCase));
Assert.IsNotNull(comm);
Assert.That(comm.Vote, Is.False);
}
public async Task Comments_Invalid_Url_But_Valid_User(KnownChains apiName)
{
var request = new NamedInfoModel("@asduj/qweqweqweqw");
var response = await Api[apiName].GetComments(request, CancellationToken.None);
Assert.That(response.Error.Message.Contains("Wrong identifier."));
}
public async Task GetPostInfo_Invalid_Url(KnownChains apiName)
{
var request = new NamedInfoModel("spam/@joseph.kalu/qweqeqwqweqweqwe");
var response = await Api[apiName].GetPostInfo(request, CancellationToken.None);
Assert.That(response.Error.Message.Contains("Wrong identifier."));
}
public async Task GetPostInfoTest(KnownChains apiName, [Values()] string url)
{
var request = new NamedInfoModel(url)
{
ShowNsfw = true,
ShowLowRated = true
};
var result = await Gateway[apiName].GetPostInfo(request, CancellationToken.None);
Assert.IsTrue(result.IsSuccess, result.Error?.Message);
}
public async Task Comments_Without_User_Check_False_Votes(KnownChains apiName)
{
var request = new PostsModel(PostType.Hot);
var posts = await Api[apiName].GetPosts(request, CancellationToken.None);
var infoModel = new NamedInfoModel(posts.Result.Results.First(i => i.Children > 0).Url);
var response = await Api[apiName].GetComments(infoModel, CancellationToken.None);
AssertResult(response);
Assert.That(response.Result.Results.Where(x => x.Vote).Any, Is.False);
}
private async Task <ErrorBase> LoadPostInfo(string url, CancellationToken ct)
{
var request = new NamedInfoModel(url)
{
Login = AppSettings.User.Login
};
var response = await Api.GetPostInfo(request, ct);
var error = ResponseProcessing(response, nameof(TryLoadPostInfo));
return(error);
}
private async Task <Exception> LoadPostInfo(string url, CancellationToken ct)
{
var request = new NamedInfoModel(url)
{
ShowNsfw = AppSettings.User.IsNsfw,
ShowLowRated = AppSettings.User.IsLowRated,
Login = AppSettings.User.Login
};
var response = await Api.GetPostInfo(request, ct);
var exception = ResponseProcessing(response, nameof(TryLoadPostInfo));
return(exception);
}
public async Task <OperationResult <Post> > Vote(VoteModel model, CancellationToken ct)
{
var results = Validate(model);
if (results != null)
{
return(new OperationResult <Post>(results));
}
var result = await _ditchClient.Vote(model, ct);
var startDelay = DateTime.Now;
await Trace($"post/@{model.Author}/{model.Permlink}/{model.Type.GetDescription()}", model.Login, result.Exception, $"@{model.Author}/{model.Permlink}", ct);
if (!result.IsSuccess)
{
return(new OperationResult <Post>(result.Exception));
}
OperationResult <Post> postInfo;
if (model.IsComment) //TODO: << delete when comment update support will added on backend
{
postInfo = new OperationResult <Post> {
Result = model.Post
};
}
else
{
var infoModel = new NamedInfoModel($"@{model.Author}/{model.Permlink}")
{
Login = model.Login,
ShowLowRated = true,
ShowNsfw = true
};
postInfo = await GetPostInfo(infoModel, ct);
}
var delay = (int)(model.VoteDelay - (DateTime.Now - startDelay).TotalMilliseconds);
if (delay > 100)
{
await Task.Delay(delay, ct);
}
return(postInfo);
}
private async Task <ErrorBase> LoadPostInfo(string url, CancellationToken ct)
{
var request = new NamedInfoModel(url)
{
Login = User.Login
};
var response = await Api.GetPostInfo(request, ct);
if (response.IsSuccess)
{
PostInfo = response.Result;
CashPresenterManager.Add(PostInfo);
NotifySourceChanged(nameof(TryLoadPostInfo), true);
}
return(response.Error);
}
private async Task <ErrorBase> LoadNextComments(string postUrl, CancellationToken ct)
{
var request = new NamedInfoModel(postUrl)
{
Login = User.Login
};
ErrorBase error;
var isNeedClearItems = true;
bool isNeedRepeat;
do
{
var response = await Api.GetComments(request, ct);
isNeedRepeat = ResponseProcessing(response, ItemsLimit, out error, nameof(TryLoadNextComments), isNeedClearItems, true);
isNeedClearItems = false;
} while (isNeedRepeat);
return(error);
}
private async Task <Exception> LoadNextComments(Post post, CancellationToken ct)
{
var request = new NamedInfoModel(post.Url)
{
Login = AppSettings.User.Login
};
Exception exception;
var isNeedClearItems = true;
bool isNeedRepeat;
do
{
var response = await Api.GetComments(request, ct);
isNeedRepeat = ResponseProcessing(response, ItemsLimit, out exception, nameof(TryLoadNextComments), isNeedClearItems, true);
isNeedClearItems = false;
} while (isNeedRepeat);
return(exception);
}
public async Task <OperationResult <VoidResponse> > CreateOrEditPost(PreparePostModel model, CancellationToken ct)
{
var operationResult = await PreparePost(model, ct);
if (!operationResult.IsSuccess)
{
return(new OperationResult <VoidResponse>(operationResult.Exception));
}
var preparedData = operationResult.Result;
var meta = JsonConvert.SerializeObject(preparedData.JsonMetadata);
var commentModel = new CommentModel(model, preparedData.Body, meta);
if (!model.IsEditMode)
{
commentModel.Beneficiaries = preparedData.Beneficiaries;
}
var result = await _ditchClient.CreateOrEdit(commentModel, ct);
if (model.IsEditMode)
{
await Trace($"post/{model.PostPermlink}/edit", model.Login, result.Exception, model.PostPermlink, ct);
}
else
{
await Trace("post", model.Login, result.Exception, model.PostPermlink, ct);
}
var infoModel = new NamedInfoModel($"@{model.Author}/{model.Permlink}")
{
Login = model.Login,
ShowLowRated = true,
ShowNsfw = true
};
var postInfo = await GetPostInfo(infoModel, ct);
return(result);
}
public async Task <OperationResult <Post> > GetPostInfo(NamedInfoModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results.Any())
{
return(new OperationResult <Post>(new ValidationError(string.Join(Environment.NewLine, results.Select(i => i.ErrorMessage)))));
}
var parameters = new Dictionary <string, object>();
AddLoginParameter(parameters, model.Login);
AddCensorParameters(parameters, model);
var endpoint = $"post/{model.Url}/info";
return(await Gateway.Get <Post>(GatewayVersion.V1P1, endpoint, parameters, token));
}
public async Task <OperationResult <ListResponse <Post> > > GetComments(NamedInfoModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results.Any())
{
return(new OperationResult <ListResponse <Post> >(new ValidationError(results)));
}
var parameters = new Dictionary <string, object>();
AddOffsetLimitParameters(parameters, model.Offset, model.Limit);
AddLoginParameter(parameters, model.Login);
var endpoint = $"post/{model.Url}/comments";
return(await Gateway.Get <ListResponse <Post> >(GatewayVersion.V1P1, endpoint, parameters, token));
}
public async Task <OperationResult <Post> > GetPostInfo(NamedInfoModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results != null)
{
return(new OperationResult <Post>(results));
}
var parameters = new Dictionary <string, object>();
AddLoginParameter(parameters, model.Login);
AddCensorParameters(parameters, model);
var endpoint = $"{BaseUrl}/{GatewayVersion.V1P1}/post/{model.Url}/info";
return(await HttpClient.Get <Post>(endpoint, parameters, token));
}
public async Task Comments_With_User_Check_True_Votes(KnownChains apiName)
{
var request = new PostsModel(PostType.Hot);
var posts = await Api[apiName].GetPosts(request, CancellationToken.None);
var isVoted = false;
var user = Users[apiName];
foreach (var post in posts.Result.Results.Where(i => i.Children > 0))
{
var infoModel = new NamedInfoModel(post.Url)
{
Login = user.Login
};
var response = await Api[apiName].GetComments(infoModel, CancellationToken.None);
AssertResult(response);
isVoted = response.Result.Results.Any(x => x.Vote);
if (isVoted)
{
break;
}
}
Assert.IsTrue(isVoted);
}
private void CreateCommentTest(StringBuilder sb, int num)
{
sb.Append($"{num}) CreateCommentTest : ");
StepFinished?.Invoke(sb.ToString());
// Load last created post
var getPosts = new PostsModel(PostType.New)
{
Login = _user.Login
};
var postsResp = _api.GetPosts(getPosts, CancellationToken.None)
.Result;
if (!postsResp.IsSuccess)
{
sb.AppendLine($"fail. Reason:{Environment.NewLine} {postsResp.Error.Message}");
return;
}
if (postsResp.Result.Results.Count == 0)
{
sb.AppendLine("fail. Reason:{Environment.NewLine} There are no Posts!");
return;
}
var testPost = postsResp.Result.Results.First();
var req = new CreateOrEditCommentModel(_user, testPost, "Hi, I am a bot for testing Ditch api, please ignore this comment.", _appInfo);
var rez = _api.CreateOrEditComment(req, CancellationToken.None)
.Result;
if (!UrlHelper.TryCastUrlToAuthorAndPermlink(testPost.Url, out var parentAuthor, out var parentPermlink))
{
sb.AppendLine($"fail. Reason:{Environment.NewLine} url to permlink cast.");
return;
}
var permlink = OperationHelper.CreateReplyPermlink(_user.Login, parentAuthor, parentPermlink);
if (!rez.IsSuccess)
{
sb.AppendLine($"fail. Reason:{Environment.NewLine} {rez.Error.Message}");
return;
}
Task.Delay(10000);
var getComm = new NamedInfoModel(testPost.Url)
{
Offset = permlink, Limit = 1
};
var verifyPostresp = _api.GetComments(getComm, CancellationToken.None)
.Result;
if (!verifyPostresp.IsSuccess)
{
sb.AppendLine($"fail. Reason:{Environment.NewLine} {verifyPostresp.Error.Message}");
return;
}
if (verifyPostresp.Result.Results.Count != 1)
{
sb.AppendLine($"fail. Reason:{Environment.NewLine} Comment ({permlink}) not found!");
return;
}
sb.AppendLine("pass.");
}
