1273 lines
46 KiB
C#
1273 lines
46 KiB
C#
// Copyright (c) The Geekeey Authors
|
|
// SPDX-License-Identifier: EUPL-1.2
|
|
|
|
using System.Globalization;
|
|
|
|
namespace Geekeey.Request.Result.Tests;
|
|
|
|
internal sealed class ResultTransformTests
|
|
{
|
|
[Test]
|
|
public async Task I_can_map_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.Map(value => value.ToString(CultureInfo.InvariantCulture));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_and_it_returns_failure_for_failure()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = start.Map(value => value.ToString(CultureInfo.InvariantCulture));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_with_then_and_it_returns_success_for_success_and_mapping_returning_success()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.Then(value => Prelude.Success(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.Then(_ => Prelude.Failure<string>("error"));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_with_then_and_it_returns_failure_for_failure_and_mapping_returning_success()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = start.Then(value => Prelude.Success(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = start.Then(_ => Prelude.Failure<int>("error 2"));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_and_it_returns_success_for_success_without_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.TryMap(value => value.ToString(CultureInfo.InvariantCulture));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_and_it_returns_failure_for_failure_without_throwing()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = start.TryMap(value => value.ToString(CultureInfo.InvariantCulture));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_and_it_returns_failure_for_success_with_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.TryMap<string>(_ => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_and_it_returns_failure_for_failure_with_throwing()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = start.TryMap<string>(_ => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_with_then_and_it_returns_success_for_success_and_mapping_returning_success()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.ThenTry(value => Prelude.Success(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.ThenTry(_ => Prelude.Failure<string>("error"));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = start.ThenTry(x => Prelude.Success(x.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_with_then_and_it_returns_failure_for_success_and_mapping_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.ThenTry<string>(_ => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_with_then_and_it_returns_failure_for_failure_and_mapping_throwing()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = start.ThenTry<string>(_ => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_async_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.MapAsync(value => Task.FromResult(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_async_and_it_returns_failure_for_failure()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.MapAsync(value => Task.FromResult(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_async_with_then_and_it_returns_success_for_success_and_mapping_returning_success()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenAsync(value => Task.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenAsync(_ => Task.FromResult(Prelude.Failure<string>("error")));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_success()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenAsync(value => Task.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenAsync(_ => Task.FromResult(Prelude.Failure<int>("error 2")));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_success_for_success_without_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.TryMapAsync(value => Task.FromResult(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_failure_without_throwing()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.TryMapAsync(value => Task.FromResult(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_success_with_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.TryMapAsync(Task<string> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_success_with_await_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.TryMapAsync(async Task<string> (_) =>
|
|
{
|
|
await Task.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_failure_with_throwing()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.TryMapAsync(Task<string> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_failure_with_await_throwing()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.TryMapAsync(async Task<string> (_) =>
|
|
{
|
|
await Task.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_success_for_success_and_mapping_returning_success()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(value => Task.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(_ => Task.FromResult(Prelude.Failure<string>("error")));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenTryAsync(x => Task.FromResult(Prelude.Success(x.ToString(CultureInfo.InvariantCulture))));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(Task<Result<string>> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_await_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(async Task<Result<string>> (_) =>
|
|
{
|
|
await Task.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_throwing()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenTryAsync(Task<Result<string>> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_await_throwing()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenTryAsync(async Task<Result<string>> (_) =>
|
|
{
|
|
await Task.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_async_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.MapAsync(value => ValueTask.FromResult(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_async_and_it_returns_failure_for_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.MapAsync(value => ValueTask.FromResult(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_async_with_then_and_it_returns_success_for_success_and_mapping_returning_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenAsync(value => ValueTask.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenAsync(_ => ValueTask.FromResult(Prelude.Failure<string>("error")));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_success_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenAsync(value => ValueTask.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenAsync(_ => ValueTask.FromResult(Prelude.Failure<int>("error 2")));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_success_for_success_without_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.TryMapAsync(value => ValueTask.FromResult(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_failure_without_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.TryMapAsync(value => ValueTask.FromResult(value.ToString(CultureInfo.InvariantCulture)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_success_with_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.TryMapAsync(ValueTask<string> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_success_with_await_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.TryMapAsync(async ValueTask<string> (_) =>
|
|
{
|
|
await ValueTask.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_failure_with_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.TryMapAsync(ValueTask<string> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_async_and_it_returns_failure_for_failure_with_await_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.TryMapAsync(async ValueTask<string> (_) =>
|
|
{
|
|
await ValueTask.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_success_for_success_and_mapping_returning_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(value => ValueTask.FromResult(Prelude.Success(value.ToString(CultureInfo.InvariantCulture))));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo("2");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_returning_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(_ => ValueTask.FromResult(Prelude.Failure<string>("error")));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_returning_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenTryAsync(x => ValueTask.FromResult(Prelude.Success(x.ToString(CultureInfo.InvariantCulture))));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(ValueTask<Result<string>> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_success_and_mapping_await_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(async ValueTask<Result<string>> (_) =>
|
|
{
|
|
await ValueTask.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenTryAsync(ValueTask<Result<string>> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_with_then_and_it_returns_failure_for_failure_and_mapping_await_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenTryAsync(async ValueTask<Result<string>> (_) =>
|
|
{
|
|
await ValueTask.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error).IsTypeOf<StringError>();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_non_generic_result_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = start.Map(() => 42);
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_non_generic_result_and_it_returns_failure_for_failure()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = start.Map(() => 42);
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_and_it_returns_failure_for_exception()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = start.TryMap<int>(() => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_with_then_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = start.Then(Prelude.Success);
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_with_then_to_generic_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = start.Then(() => Prelude.Success(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_generic_result_with_then_to_non_generic_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success(42);
|
|
var result = start.Then(_ => Prelude.Success());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_non_generic_result_async_and_it_returns_success_for_success_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.MapAsync(() => Task.FromResult(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_exception_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.TryMapAsync((Func<Task<int>>)(() => throw new CustomTestException()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_async_with_then_and_it_returns_success_for_success_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenAsync(() => Task.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_generic_result_async_with_then_to_non_generic_and_it_returns_success_for_success_Task()
|
|
{
|
|
var start = Prelude.Success(42);
|
|
var result = await start.ThenAsync(_ => Task.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_non_generic_result_async_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.MapAsync(() => ValueTask.FromResult(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_exception_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.TryMapAsync((Func<ValueTask<int>>)(() => throw new CustomTestException()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_generic_result_async_with_then_to_non_generic_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success(42);
|
|
var result = await start.ThenAsync(_ => ValueTask.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_to_non_generic_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.ThenTry(value => Prelude.Success());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_to_non_generic_and_it_returns_failure_for_success_and_mapping_returning_failure()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.ThenTry(_ => Prelude.Failure("error"));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_to_non_generic_and_it_returns_failure_for_success_and_mapping_throwing()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = start.ThenTry(_ => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_success_for_success_Task()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(value => Task.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_failure_for_success_and_mapping_throwing_Task()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(Task<Result> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(value => ValueTask.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_failure_for_success_and_mapping_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(ValueTask<Result> (_) => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_with_then_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = start.ThenTry(Prelude.Success);
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_with_then_and_it_returns_failure_for_exception()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = start.ThenTry(() => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_with_then_to_generic_and_it_returns_success_for_success()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = start.ThenTry(() => Prelude.Success(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_with_then_to_generic_and_it_returns_failure_for_exception()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = start.ThenTry<int>(() => throw new CustomTestException());
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_non_generic_result_async_and_it_returns_failure_for_failure_Task()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = await start.MapAsync(() => Task.FromResult(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_async_and_it_returns_success_for_success_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.TryMapAsync(() => Task.FromResult(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_failure_Task()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = await start.TryMapAsync(() => Task.FromResult(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_await_exception_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.TryMapAsync((Func<Task<int>>)(async () =>
|
|
{
|
|
await Task.CompletedTask;
|
|
throw new CustomTestException();
|
|
}));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_async_with_then_and_it_returns_failure_for_failure_Task()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = await start.ThenAsync(() => Task.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_success_for_success_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync(() => Task.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_failure_for_exception_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync((Func<Task<Result>>)(() => throw new CustomTestException()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_failure_for_await_exception_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync((Func<Task<Result>>)(async () =>
|
|
{
|
|
await Task.CompletedTask;
|
|
throw new CustomTestException();
|
|
}));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_async_with_then_to_generic_and_it_returns_success_for_success_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenAsync(() => Task.FromResult(Prelude.Success(42)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_failure_Task()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = await start.ThenAsync(() => Task.FromResult(Prelude.Success(42)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_success_for_success_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync(() => Task.FromResult(Prelude.Success(42)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_exception_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync((Func<Task<Result<int>>>)(() => throw new CustomTestException()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_await_exception_Task()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync((Func<Task<Result<int>>>)(async () =>
|
|
{
|
|
await Task.CompletedTask;
|
|
throw new CustomTestException();
|
|
}));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_generic_result_async_with_then_to_non_generic_and_it_returns_failure_for_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Failure<int>("error");
|
|
var result = await start.ThenAsync(_ => ValueTask.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_failure_for_success_and_mapping_returning_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(_ => ValueTask.FromResult(Prelude.Failure("error")));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_result_async_to_non_generic_and_it_returns_failure_for_success_and_mapping_await_throwing_ValueTask()
|
|
{
|
|
var start = Prelude.Success(2);
|
|
var result = await start.ThenTryAsync(async ValueTask<Result> (_) =>
|
|
{
|
|
await ValueTask.CompletedTask;
|
|
throw new CustomTestException();
|
|
});
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_map_non_generic_result_async_and_it_returns_failure_for_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = await start.MapAsync(() => ValueTask.FromResult(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_async_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.TryMapAsync(() => ValueTask.FromResult(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = await start.TryMapAsync(() => ValueTask.FromResult(42));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_map_non_generic_result_async_and_it_returns_failure_for_await_exception_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.TryMapAsync((Func<ValueTask<int>>)(async () =>
|
|
{
|
|
await ValueTask.CompletedTask;
|
|
throw new CustomTestException();
|
|
}));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_async_with_then_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenAsync(() => ValueTask.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_async_with_then_and_it_returns_failure_for_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = await start.ThenAsync(() => ValueTask.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync(() => ValueTask.FromResult(Prelude.Success()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_failure_for_exception_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync((Func<ValueTask<Result>>)(() => throw new CustomTestException()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_and_it_returns_failure_for_await_exception_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync((Func<ValueTask<Result>>)(async () =>
|
|
{
|
|
await ValueTask.CompletedTask;
|
|
throw new CustomTestException();
|
|
}));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_async_with_then_to_generic_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenAsync(() => ValueTask.FromResult(Prelude.Success(42)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_failure_ValueTask()
|
|
{
|
|
var start = Prelude.Failure("error");
|
|
var result = await start.ThenAsync(() => ValueTask.FromResult(Prelude.Success(42)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
await Assert.That(result.Error?.Message).IsEqualTo("error");
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_success_for_success_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync(() => ValueTask.FromResult(Prelude.Success(42)));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsTrue();
|
|
await Assert.That(result.Value).IsEqualTo(42);
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_exception_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync((Func<ValueTask<Result<int>>>)(() => throw new CustomTestException()));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
|
|
[Test]
|
|
public async Task I_can_try_transform_non_generic_result_async_with_then_to_generic_and_it_returns_failure_for_await_exception_ValueTask()
|
|
{
|
|
var start = Prelude.Success();
|
|
var result = await start.ThenTryAsync((Func<ValueTask<Result<int>>>)(async () =>
|
|
{
|
|
await ValueTask.CompletedTask;
|
|
throw new CustomTestException();
|
|
}));
|
|
|
|
using var scope = Assert.Multiple();
|
|
await Assert.That(result.IsSuccess).IsFalse();
|
|
var instance = await Assert.That(result.Error).IsTypeOf<ExceptionError>();
|
|
await Assert.That(instance?.Exception).IsTypeOf<CustomTestException>();
|
|
}
|
|
}
|