public async Task SearchUserTest(KnownChains apiName)
{
var request = new SearchWithQueryModel("aar");
var result = await Gateway[apiName].SearchUser(request, CancellationToken.None);
Assert.IsTrue(result.IsSuccess, result.Exception?.Message);
}
private async Task <ErrorBase> LoadNext(string s, CancellationToken ct)
{
var request = new SearchWithQueryModel(s.TagToEn())
{
Offset = OffsetUrl,
Limit = ItemsLimit
};
var response = await Api.SearchCategories(request, ct);
if (response.IsSuccess)
{
var tags = response.Result.Results;
if (tags.Count > 0)
{
lock (Items)
Items.AddRange(Items.Count == 0 ? tags : tags.Skip(1));
OffsetUrl = tags.Last().Name;
}
if (tags.Count < Math.Min(ServerMaxCount, ItemsLimit))
{
IsLastReaded = true;
}
NotifySourceChanged(nameof(TryLoadNext), true);
}
return(response.Error);
}
private async Task <ErrorBase> LoadNextSearchUser(string query, CancellationToken ct)
{
var request = new SearchWithQueryModel(query)
{
Limit = ItemsLimit,
Offset = OffsetUrl,
Login = AppSettings.User.Login
};
var response = await Api.SearchUser(request, ct);
if (response.IsSuccess)
{
var result = response.Result.Results;
if (result.Count > 0)
{
lock (Items)
{
Items.AddRange(Items.Count == 0 ? result : result.Skip(1));
CashPresenterManager.Add(Items.Count == 0 ? result : result.Skip(1));
}
OffsetUrl = result.Last().Author;
}
if (result.Count < Math.Min(ServerMaxCount, ItemsLimit))
{
IsLastReaded = true;
}
NotifySourceChanged(nameof(TryLoadNextSearchUser), true);
}
return(response.Error);
}
private void SearchCategoriesTest(StringBuilder sb, int num)
{
sb.Append($"{num}) SearchCategoriesTest : ");
StepFinished?.Invoke(sb.ToString());
var limit = 3;
var request = new SearchWithQueryModel("go")
{
Limit = limit
};
var response = _api.SearchCategories(request, CancellationToken.None).Result;
if (IsError1(sb, limit, response, response.Result.Results.Count))
{
return;
}
request.Offset = response.Result.Results.Last().Name;
response = _api.SearchCategories(request, CancellationToken.None).Result;
if (IsError2(sb, limit, response, request.Offset))
{
return;
}
sb.AppendLine("pass.");
}
public async Task SearchCategoriesTest(KnownChains apiName)
{
var request = new SearchWithQueryModel("ru");
var result = await Gateway[apiName].SearchCategories(request, CancellationToken.None);
Assert.IsTrue(result.IsSuccess, result.Error?.Message);
}
public async Task Categories_Search_Empty_Query(KnownChains apiName)
{
var request = new SearchWithQueryModel(" ");
var response = await Api[apiName].SearchCategories(request, CancellationToken.None);
Assert.IsTrue(response.Error.Message.StartsWith(nameof(LocalizationKeys.EmptyCategory)));
}
public async Task User_Search_Offset_Not_Exisiting(KnownChains apiName)
{
var request = new SearchWithQueryModel("aar")
{
Offset = "qweqweqwe"
};
var response = await Api[apiName].SearchUser(request, CancellationToken.None);
Assert.IsTrue(response.Error.Message.Equals("Username used for offset was not found"));
}
public async Task User_Search_Short_Query(KnownChains apiName)
{
// Arrange
var request = new SearchWithQueryModel("fo");
// Act
var response = await Api[apiName].SearchUser(request, CancellationToken.None);
// Assert
Assert.IsTrue(response.Error.Message.Equals("Query should have at least 3 characters"));
}
public async Task Categories_Search_Short_Query(KnownChains apiName)
{
// Arrange
var request = new SearchWithQueryModel("f");
// Act
var response = await Api[apiName].SearchCategories(request, CancellationToken.None);
// Assert
Assert.IsTrue(response.Error.Message.StartsWith(nameof(LocalizationKeys.QueryMinLength)));
}
public async Task User_Search_Empty_Query(KnownChains apiName)
{
// Arrange
var request = new SearchWithQueryModel(" ");
// Act
var response = await Api[apiName].SearchUser(request, CancellationToken.None);
// Assert
Assert.IsTrue(response.Error.Message.Equals(nameof(LocalizationKeys.EmptyCategory)));
}
public async Task Categories_Search_With_User(KnownChains apiName)
{
var request = new SearchWithQueryModel("lif");
var response = await Api[apiName].SearchCategories(request, CancellationToken.None);
AssertResult(response);
Assert.That(response.Result.Results.Any());
Assert.That(response.Result.Results, Is.Not.Empty);
Assert.That(response.Result.Results.First().Name, Is.Not.Empty);
}
public async Task Categories_Search_Invalid_Query(KnownChains apiName)
{
// Arrange
var request = new SearchWithQueryModel("qwerqwerqwerqwerqwerqwerqwerqwer");
// Act
var response = await Api[apiName].SearchCategories(request, CancellationToken.None);
// Assert
AssertResult(response);
Assert.That(response.Result.Results, Is.Empty);
}
public async Task Categories_Search_Offset_Not_Exisiting(KnownChains apiName)
{
// Arrange
var request = new SearchWithQueryModel("life")
{
Offset = "qweqweqwe"
};
// Act
var response = await Api[apiName].SearchCategories(request, CancellationToken.None);
// Assert
Assert.That(response.Error.Message.Contains("Category used for offset was not found"));
}
public void CancelationTest()
{
// Arrange
// Act
var ex = Assert.Throws <AggregateException>(() =>
{
var request = new SearchWithQueryModel("aar");
var cts = new CancellationTokenSource(TimeSpan.FromMilliseconds(100));
var operationResult = Api[KnownChains.Steem].SearchUser(request, cts.Token).Result;
});
// Assert
Assert.That(ex.InnerException.Message, Is.EqualTo("A task was canceled."));
}
public async Task User_Search(KnownChains apiName)
{
// Arrange
var request = new SearchWithQueryModel("aar");
// Act
var response = await Api[apiName].SearchUser(request, CancellationToken.None);
// Assert
AssertResult(response);
Assert.That(response.Result.Results, Is.Not.Empty);
Assert.That(response.Result.Results, Is.Not.Empty);
Assert.That(response.Result.Results.First().Author, Is.Not.Empty);
}
private async Task <ErrorBase> LoadNext(Tuple <string, bool, bool> queryParams, CancellationToken ct)
{
if (queryParams.Item2)
{
Clear();
}
var request = new SearchWithQueryModel(queryParams.Item1.TagToEn())
{
Offset = OffsetUrl,
Limit = ItemsLimit
};
var response = await Api.SearchCategories(request, ct);
if (response.IsSuccess)
{
if (queryParams.Item2)
{
Clear();
}
var tags = response.Result.Results;
if (tags.Count > 0)
{
lock (Items)
{
Items.AddRange(Items.Count == 0 ? tags : tags.Skip(1));
}
OffsetUrl = tags.Last().Name;
}
else if ((Items.Count == 0 || Items.Count == 1) && queryParams.Item3)
{
lock (Items)
Items.Add(new SearchResult()
{
Name = queryParams.Item1
});
}
if (tags.Count < Math.Min(ServerMaxCount, ItemsLimit))
{
IsLastReaded = true;
}
NotifySourceChanged(nameof(TryLoadNext), true);
}
return(response.Error);
}
public async Task Categories_Search_Offset_Limit(KnownChains apiName)
{
// Arrange
const int limit = 5;
var request = new SearchWithQueryModel("bit")
{
Offset = "bitcoin",
Limit = limit
};
// Act
var response = await Api[apiName].SearchCategories(request, CancellationToken.None);
// Assert
AssertResult(response);
Assert.That(response.Result.Results.Count, Is.EqualTo(limit));
Assert.That(response.Result.Results, Is.Not.Empty);
Assert.That(response.Result.Results.First().Name, Is.EqualTo("bitcoin"));
}
public async Task <OperationResult <ListResponse <UserFriend> > > SearchUser(SearchWithQueryModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results.Any())
{
return(new OperationResult <ListResponse <UserFriend> >(new ValidationError(string.Join(Environment.NewLine, results.Select(i => i.ErrorMessage)))));
}
var parameters = new Dictionary <string, object>();
AddLoginParameter(parameters, model.Login);
AddOffsetLimitParameters(parameters, model.Offset, model.Limit);
parameters.Add("query", model.Query);
var endpoint = "user/search";
return(await Gateway.Get <ListResponse <UserFriend> >(GatewayVersion.V1P1, endpoint, parameters, token));
}
public async Task <OperationResult <ListResponse <UserFriend> > > SearchUser(SearchWithQueryModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results != null)
{
return(new OperationResult <ListResponse <UserFriend> >(results));
}
var parameters = new Dictionary <string, object>();
AddLoginParameter(parameters, model.Login);
AddOffsetLimitParameters(parameters, model.Offset, model.Limit);
parameters.Add("query", model.Query);
var endpoint = $"{BaseUrl}/{GatewayVersion.V1P1}/user/search";
return(await HttpClient.Get <ListResponse <UserFriend> >(endpoint, parameters, token));
}
public async Task <OperationResult <ListResponse <SearchResult> > > SearchCategories(SearchWithQueryModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results.Any())
{
return(new OperationResult <ListResponse <SearchResult> >(new ValidationError(string.Join(Environment.NewLine, results.Select(i => i.ErrorMessage)))));
}
var query = Transliteration.ToEng(model.Query);
if (query != model.Query)
{
query = $"ru--{query}";
}
model.Query = query;
var parameters = new Dictionary <string, object>();
AddOffsetLimitParameters(parameters, model.Offset, model.Limit);
parameters.Add("query", model.Query);
var endpoint = "categories/search";
var result = await Gateway.Get <ListResponse <SearchResult> >(GatewayVersion.V1, endpoint, parameters, token);
if (result.IsSuccess)
{
foreach (var categories in result.Result.Results)
{
categories.Name = Transliteration.ToRus(categories.Name);
}
}
return(result);
}
public async Task <OperationResult <ListResponse <SearchResult> > > SearchCategories(SearchWithQueryModel model, CancellationToken token)
{
if (!EnableRead)
{
return(null);
}
var results = Validate(model);
if (results != null)
{
return(new OperationResult <ListResponse <SearchResult> >(results));
}
var query = Transliteration.ToEng(model.Query);
if (query != model.Query)
{
query = $"ru--{query}";
}
model.Query = query;
var parameters = new Dictionary <string, object>();
AddOffsetLimitParameters(parameters, model.Offset, model.Limit);
parameters.Add("query", model.Query);
var endpoint = $"{BaseUrl}/{GatewayVersion.V1P1}/categories/search";
var result = await HttpClient.Get <ListResponse <SearchResult> >(endpoint, parameters, token);
if (result.IsSuccess)
{
foreach (var categories in result.Result.Results)
{
categories.Name = Transliteration.ToRus(categories.Name);
}
}
return(result);
}
