public async Task Validate_TaskPredicateがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.Validate(
source: Result.Ok("A"),
predicate: (Func <string, Task <bool> >)null);
await act.Should().ThrowAsync <ArgumentNullException>();
}
public async Task AsyncSync_sourceパラメーターが指定されていない場合は例外が発生する()
{
Func <Task> act = () => ResultExtensions.MapError((Task <Result <string> >)null, _ => new Error());
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("source");
}
public async Task T_全て成功の場合は成功になる()
{
var result = await ResultExtensions.Merge(new[] { Result.Ok("A").AsTask(), Result.Ok("B").AsTask() });
result.Should().BeOk();
result.Get().Should().HaveCount(2);
}
private async Task <Result <PlexDownloadClient> > CreateDownloadClientAsync(DownloadTask downloadTask)
{
if (downloadTask == null)
{
return(ResultExtensions.IsNull(nameof(downloadTask)).LogError());
}
var authenticateDownloadTaskResult = await AuthenticateDownloadTask(downloadTask);
if (authenticateDownloadTaskResult.IsFailed)
{
return(authenticateDownloadTaskResult.ToResult().LogError());
}
// Create download client
var newClient = _plexDownloadClientFactory(downloadTask);
newClient.Parts = _userSettings.AdvancedSettings.DownloadManager.DownloadSegments;
// Setup the client
var setupResult = await newClient.SetupAsync(downloadTask.DownloadWorkerTasks);
if (setupResult.IsFailed)
{
return(setupResult.ToResult());
}
SetupSubscriptions(newClient);
_downloadsList.Add(newClient);
return(Result.Ok(newClient));
}
public void 全て成功の場合は成功になる()
{
var result = ResultExtensions.Merge(new[] { Result.Ok("A"), Result.Ok("B") });
result.Should().BeOk();
result.Get().Should().HaveCount(2);
}
public async Task AsyncSync_sourceが指定されていない場合は例外が発生する()
{
var act = () => ResultExtensions.TapError(null as Task <Result>, _ => { });
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("source");
}
public async Task Async_nullの場合は例外が発生する()
{
Func<Task> act = () => ResultExtensions.ContainsError(
source: null as Task<Result<string>>,
new Error());
await act.Should().ThrowAsync<ArgumentNullException>();
}
/// <summary>
/// Fetch stock information and data
/// </summary>
/// <param name="symbol"></param>
/// <returns></returns>
public async Task <Result <StockInfoClientResponseDto> > GetStockInfo(string symbol)
{
_logger.LogInformation("Fetching data for ticker {0}", symbol);
AddQueryParam("t", symbol);
var response = await _http.GetAsync(BuildQuery());
_logger.LogInformation("Data fetched for ticker {0}", symbol);
var result = await HandleClientResponse(response);
if (!result.Succedded)
{
_logger.LogInformation("Fetchind data for ticker {0} failed -> {1}", symbol, result.Message);
return(ResultExtensions.Failure <StockInfoClientResponseDto>(result.Message));
}
if (!ContainsTickerId(result.Instance, symbol))
{
_logger.LogInformation("Ticker {0} not found", symbol);
return(ResultExtensions.Failure <StockInfoClientResponseDto>("Ticker not found"));
}
var fetchedInstance = ParseInstanceFromHtmlContent(result.Instance);
_logger.LogInformation("Data for ticker fetched and prepared");
return(ResultExtensions.Success(fetchedInstance));
}
public async Task A_全て成功の場合は成功になる()
{
var result = await ResultExtensions.Merge(Task.FromResult(new[] { Result.Ok("A"), Result.Ok("B") }.AsEnumerable()));
result.Should().BeOk();
result.Get().Should().HaveCount(2);
}
public async Task Async_Validate_TaskSourceがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.Validate(
source: (Task <Result <string> >)null,
predicate: v => Task.FromResult(true));
await act.Should().ThrowAsync <ArgumentNullException>();
}
public async Task <ResultArray <StockInfoResponseDto> > GetStockInfos(string symbol)
{
var clients = _factory.GetAllClients();
if (!clients.Any())
{
return(ResultExtensions.FailureArray <StockInfoResponseDto>("Unexpected exception"));
}
var clientTasks = await LaunchClientsCall(clients, symbol);
var finishedTasks = clientTasks.Cast <Task <Result <StockInfoClientResponseDto> > >();
var results = new List <StockInfoResponseDto>();
foreach (var finshedTask in finishedTasks)
{
var instance = HandleClientResponse(finshedTask.Result);
if (instance == null)
{
var dto = _mapper.Map <StockInfoResponseDto>(instance);
results.Add(dto);
}
}
return(ResultExtensions.Success(instances: results));
}
public async Task Async_TaskPredicateがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.ValidateError(
source: Result.Error <string>(new Error()).AsTask(),
predicate: (Func <IError, Task <bool> >)null);
await act.Should().ThrowAsync <ArgumentNullException>();
}
public async Task ReturnT_AsyncSync_sourceパラメーターが指定されていない場合は例外が発生する()
{
Func <Task> act = () => ResultExtensions.FlatMap(null as Task <Result>, () => Result.Ok("ok"));
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("source");
}
public async Task Async_Predicateがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.ValidateError(
source: Result.Ok("A").AsTask(),
predicate: (Func <IError, bool>)null);
await act.Should().ThrowAsync <ArgumentNullException>();
}
public async Task <TResponse> Handle(TRequest request, CancellationToken cancellationToken,
RequestHandlerDelegate <TResponse> next)
{
var fluentValidationResult = await _compositeValidator.ValidateAsync(request, cancellationToken);
if (!fluentValidationResult.IsValid)
{
var result = new TResponse();
var error = ResultExtensions.Get400BadRequestError();
foreach (var reason in fluentValidationResult.Errors)
{
error.Reasons.Add(new Error(reason.ErrorMessage));
}
result.Reasons.Add(error);
return(result);
}
// Encapsulate all handlers with this try/catch block as not to do this in every handler itself.
try
{
return(await next());
}
catch (Exception e)
{
return(Result.Fail(new ExceptionalError(e)).LogError() as TResponse);
}
}
public async Task Func_AsyncSync_Sourceがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.Combine(null as Task <Result <string> >, _ => Result.Ok("ok"));
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("source");
}
public async Task <Result <DownloadTask> > Handle(GetDownloadTaskByIdQuery request, CancellationToken cancellationToken)
{
var query = _dbContext.DownloadTasks.AsQueryable();
if (request.IncludeServer)
{
query = query.Include(x => x.PlexServer);
}
if (request.IncludePlexLibrary)
{
query = query.Include(x => x.PlexLibrary);
}
var downloadTask = await query
.Include(x => x.DownloadWorkerTasks)
.Include(x => x.DownloadFolder)
.Include(x => x.DestinationFolder)
.FirstOrDefaultAsync(x => x.Id == request.Id, cancellationToken);
if (downloadTask == null)
{
return(ResultExtensions.GetEntityNotFound(nameof(DownloadTask), request.Id));
}
return(Result.Ok(downloadTask));
}
public async Task Async_sourceがnullの場合は例外が発生する()
{
Func <Task> act = () => ResultExtensions.Empty(null as Task <Result <string> >);
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("source");
}
public async Task AsyncAsync_sourceパラメーターが指定されていない場合は例外が発生する()
{
Func <Task> act = () => ResultExtensions.Map(null as Task <Result <string> >, _ => Task.FromResult("v"));
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("source");
}
public async Task AsyncAsync_sourceが指定されていない場合は例外が発生する()
{
var act = () => ResultExtensions.Tap(null as Task <Result <string> >, _ => { return(Task.Run(() => { })); });
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("source");
}
public async Task <Result <PlexServer> > Handle(GetPlexServerByPlexTvShowEpisodeIdQuery request,
CancellationToken cancellationToken)
{
var plexTvShowEpisode = await _dbContext.PlexTvShowEpisodes
.Include(x => x.TvShowSeason)
.ThenInclude(x => x.TvShow)
.ThenInclude(x => x.PlexLibrary)
.ThenInclude(x => x.PlexServer)
.ThenInclude(x => x.ServerStatus)
.FirstOrDefaultAsync(x => x.Id == request.Id, cancellationToken);
if (plexTvShowEpisode == null)
{
return(ResultExtensions.Create404NotFoundResult());
}
var plexServer = plexTvShowEpisode?.TvShowSeason?.TvShow?.PlexLibrary?.PlexServer;
if (plexServer == null)
{
return(ResultExtensions.GetEntityNotFound(nameof(PlexServer), request.Id)
.LogError(null, $"Could not retrieve the PlexServer from PlexTvShowEpisode with id: {request.Id}"));
}
return(Result.Ok(plexServer));
}
public async Task <Result <PlexTvShow> > Handle(GetPlexTvShowByIdWithEpisodesQuery request, CancellationToken cancellationToken)
{
IQueryable <PlexTvShow> query = _dbContext.PlexTvShows.Include(x => x.Seasons)
.ThenInclude(x => x.Episodes)
.ThenInclude(x => x.EpisodeData)
.ThenInclude(x => x.Parts);
if (request.IncludeLibrary)
{
query = query
.Include(x => x.PlexLibrary)
.ThenInclude(x => x.PlexServer);
}
var plexTvShow = await query
.OrderBy(x => x.Key)
.FirstOrDefaultAsync(x => x.Id == request.Id, cancellationToken);
if (plexTvShow == null)
{
return(ResultExtensions.GetEntityNotFound(nameof(PlexTvShow), request.Id));
}
plexTvShow.Seasons = plexTvShow.Seasons.OrderBy(x => x.Title).ToList();
return(Result.Ok(plexTvShow));
}
public async Task Func_AsyncSync_Destがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.Combine(Result.Ok("Ok").AsTask(), (Func <string, Result <int> >)null);
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("dest");
}
public async Task Async_sourceがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.ValidateError(
source: null as Task <Result <string> >,
predicate: _ => true);
await act.Should().ThrowAsync <ArgumentNullException>();
}
public async Task AsyncAsync_sourceパラメーターが指定されていない場合は例外が発生する()
{
Func <Task> act = () => ResultExtensions.FlatMapError(null as Task <Result>, e => Task.Run(() => Result.Ok()));
var result = await act.Should().ThrowAsync <ArgumentNullException>();
result.And.ParamName.Should().Be("source");
}
public void Predicateがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.ValidateError(
source: Result.Error <string>(new Error()),
predicate: (Func <IError, bool>)null);
act.Should().Throw <ArgumentNullException>();
}
public void Validate_Predicateがnullの場合は例外が発生する()
{
var act = () => ResultExtensions.Validate(
source: Result.Ok("A"),
predicate: (Func <string, bool>)null);
act.Should().Throw <ArgumentNullException>();
}
public void TalkBackHelloReturnsOK()
{
var result = _talkBackController.GetHello();
var responseString = ResultExtensions.OKResponseToType(result);
result.Result.Should().BeOfType <OkObjectResult>();
responseString.Should().BeEquivalentTo("Hello World");
}
private async Task <Result <T> > HandleGoodRequest <T>(HttpResponseMessage response)
{
var content = await ReadResponseContent(response);
var instnace = JsonConvert.DeserializeObject <T>(content);
return(ResultExtensions.Success(instnace));
}
public async Task <Result> PauseDownloadTask(int downloadTaskId)
{
if (downloadTaskId <= 0)
{
return(ResultExtensions.IsInvalidId(nameof(downloadTaskId), downloadTaskId).LogWarning());
}
return(await _downloadManager.PauseDownload(downloadTaskId));
}
