From 8c1a168cdb7913cf6b076903dd7339b120623234 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 17:20:27 +0400 Subject: [PATCH 01/11] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D0=BB=D0=B8=D0=B1=D1=83=20=D0=B8=20=D1=82=D0=B5=D1=81?= =?UTF-8?q?=D1=82=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .dockerignore | 30 + .editorconfig | 138 ++++ .gitattributes | 39 ++ .github/workflows/ci.yml | 40 ++ .gitignore | 7 + AGENTS.md | 88 +++ Directory.Build.props | 43 ++ Directory.Packages.props | 13 + PANiXiDA.Core.ResultPattern.slnx | 23 + README.md | 657 +++++++++++++++++- global.json | 9 + icon.png | Bin 0 -> 416503 bytes src/PANiXiDA.Core.ResultPattern/Error.cs | 149 ++++ src/PANiXiDA.Core.ResultPattern/ErrorType.cs | 42 ++ .../GenericResult.cs | 77 ++ .../PANiXiDA.Core.ResultPattern.csproj | 20 + src/PANiXiDA.Core.ResultPattern/Result.cs | 177 +++++ .../ResultCombiner.cs | 393 +++++++++++ .../ResultExtensions.cs | 250 +++++++ .../ErrorTests.cs | 244 +++++++ .../GenericResultTests.cs | 166 +++++ ...NiXiDA.Core.ResultPattern.UnitTests.csproj | 21 + .../ResultCombinerTests.cs | 346 +++++++++ .../ResultExtensionsTests.cs | 643 +++++++++++++++++ .../ResultTests.cs | 215 ++++++ version.json | 22 + 26 files changed, 3851 insertions(+), 1 deletion(-) create mode 100644 .dockerignore create mode 100644 .editorconfig create mode 100644 .gitattributes create mode 100644 .github/workflows/ci.yml create mode 100644 .gitignore create mode 100644 AGENTS.md create mode 100644 Directory.Build.props create mode 100644 Directory.Packages.props create mode 100644 PANiXiDA.Core.ResultPattern.slnx create mode 100644 global.json create mode 100644 icon.png create mode 100644 src/PANiXiDA.Core.ResultPattern/Error.cs create mode 100644 src/PANiXiDA.Core.ResultPattern/ErrorType.cs create mode 100644 src/PANiXiDA.Core.ResultPattern/GenericResult.cs create mode 100644 src/PANiXiDA.Core.ResultPattern/PANiXiDA.Core.ResultPattern.csproj create mode 100644 src/PANiXiDA.Core.ResultPattern/Result.cs create mode 100644 src/PANiXiDA.Core.ResultPattern/ResultCombiner.cs create mode 100644 src/PANiXiDA.Core.ResultPattern/ResultExtensions.cs create mode 100644 tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs create mode 100644 tests/PANiXiDA.Core.ResultPattern.UnitTests/GenericResultTests.cs create mode 100644 tests/PANiXiDA.Core.ResultPattern.UnitTests/PANiXiDA.Core.ResultPattern.UnitTests.csproj create mode 100644 tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultCombinerTests.cs create mode 100644 tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultExtensionsTests.cs create mode 100644 tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultTests.cs create mode 100644 version.json diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..8a0a6f1 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,30 @@ +**/.classpath +**/.dockerignore +**/.env +**/.git +**/.gitignore +**/.project +**/.settings +**/.toolstarget +**/.vs +**/.vscode +**/*.*proj.user +**/*.dbmdl +**/*.jfm +**/azds.yaml +**/bin +**/charts +**/docker-compose* +**/Dockerfile* +**/node_modules +**/npm-debug.log +**/obj +**/secrets.dev.yaml +**/values.dev.yaml +LICENSE +README.md +!**/.gitignore +!.git/HEAD +!.git/config +!.git/packed-refs +!.git/refs/heads/** diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..8ed5105 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,138 @@ +[*] +indent_style = space +csharp_indent_labels = one_less_than_current +csharp_using_directive_placement = outside_namespace:silent +csharp_prefer_simple_using_statement = true:suggestion +csharp_prefer_braces = true:silent +csharp_style_namespace_declarations = file_scoped:warning +csharp_style_prefer_method_group_conversion = true:silent +csharp_style_prefer_top_level_statements = true:silent +csharp_style_prefer_primary_constructors = true:suggestion +csharp_style_expression_bodied_methods = false:silent +csharp_style_expression_bodied_constructors = false:silent +csharp_style_expression_bodied_operators = false:silent +csharp_style_expression_bodied_properties = true:silent +csharp_style_expression_bodied_indexers = true:silent +csharp_style_expression_bodied_accessors = true:silent +csharp_style_expression_bodied_lambdas = true:silent +csharp_style_expression_bodied_local_functions = false:silent +csharp_style_throw_expression = true:suggestion +csharp_style_prefer_null_check_over_type_check = true:suggestion +csharp_prefer_simple_default_expression = true:suggestion +csharp_style_prefer_local_over_anonymous_function = true:suggestion +csharp_style_prefer_index_operator = true:suggestion +csharp_style_prefer_range_operator = true:suggestion +csharp_style_implicit_object_creation_when_type_is_apparent = true:suggestion +csharp_style_prefer_tuple_swap = true:suggestion +csharp_style_prefer_utf8_string_literals = true:suggestion +csharp_style_prefer_unbound_generic_type_in_nameof = true:suggestion +csharp_style_inlined_variable_declaration = true:suggestion +csharp_style_deconstructed_variable_declaration = true:suggestion +csharp_style_unused_value_assignment_preference = discard_variable:suggestion +csharp_style_unused_value_expression_statement_preference = discard_variable:silent +csharp_style_prefer_switch_expression = true:suggestion +csharp_style_conditional_delegate_call = true:suggestion +csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion +csharp_style_prefer_pattern_matching = true:silent +csharp_style_pattern_matching_over_as_with_null_check = true:suggestion +csharp_style_prefer_not_pattern = true:suggestion +csharp_style_prefer_extended_property_pattern = true:suggestion +csharp_style_var_for_built_in_types = false:silent +csharp_style_var_when_type_is_apparent = false:silent +csharp_style_var_elsewhere = false:silent +csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true:silent +csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = true:silent +csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true:silent +csharp_style_allow_blank_lines_between_consecutive_braces_experimental = true:silent +csharp_style_allow_embedded_statements_on_same_line_experimental = true:silent +csharp_prefer_system_threading_lock = true:suggestion +csharp_style_prefer_readonly_struct_member = true:suggestion +csharp_style_prefer_readonly_struct = true:suggestion +csharp_prefer_static_anonymous_function = true:suggestion +csharp_prefer_static_local_function = true:suggestion +csharp_space_around_binary_operators = before_and_after + +[*.{cs,vb}] +#### Naming styles #### + +# Naming rules + +dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion +dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface +dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i + +dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.types_should_be_pascal_case.symbols = types +dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case + +dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members +dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case + +# Symbol specifications + +dotnet_naming_symbols.interface.applicable_kinds = interface +dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.interface.required_modifiers = + +dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum +dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.types.required_modifiers = + +dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method +dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.non_field_members.required_modifiers = + +# Naming styles + +dotnet_naming_style.begins_with_i.required_prefix = I +dotnet_naming_style.begins_with_i.required_suffix = +dotnet_naming_style.begins_with_i.word_separator = +dotnet_naming_style.begins_with_i.capitalization = pascal_case + +dotnet_naming_style.pascal_case.required_prefix = +dotnet_naming_style.pascal_case.required_suffix = +dotnet_naming_style.pascal_case.word_separator = +dotnet_naming_style.pascal_case.capitalization = pascal_case + +dotnet_naming_style.pascal_case.required_prefix = +dotnet_naming_style.pascal_case.required_suffix = +dotnet_naming_style.pascal_case.word_separator = +dotnet_naming_style.pascal_case.capitalization = pascal_case +dotnet_style_operator_placement_when_wrapping = beginning_of_line +tab_width = 4 +indent_size = 4 +end_of_line = lf +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion +dotnet_style_prefer_auto_properties = true:silent +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_prefer_simplified_boolean_expressions = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:silent +dotnet_style_prefer_conditional_expression_over_return = true:silent +dotnet_style_explicit_tuple_names = true:warning +dotnet_style_prefer_inferred_tuple_names = true:suggestion +dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion +dotnet_style_prefer_compound_assignment = true:suggestion +dotnet_style_prefer_simplified_interpolation = true:warning +dotnet_style_prefer_collection_expression = when_types_loosely_match:suggestion +dotnet_style_namespace_match_folder = true:suggestion +dotnet_code_quality_unused_parameters = all:suggestion +dotnet_style_predefined_type_for_locals_parameters_members = true:silent +dotnet_style_predefined_type_for_member_access = true:silent +dotnet_style_qualification_for_field = false:silent +dotnet_style_qualification_for_property = false:silent +dotnet_style_qualification_for_method = false:silent +dotnet_style_qualification_for_event = false:silent +dotnet_style_allow_statement_immediately_after_block_experimental = true:silent +dotnet_style_allow_multiple_blank_lines_experimental = true:silent +dotnet_style_require_accessibility_modifiers = for_non_interface_members:silent +dotnet_style_parentheses_in_other_operators = never_if_unnecessary:silent +dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:silent +dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:silent +dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:silent +dotnet_style_readonly_field = true:suggestion +dotnet_diagnostic.IDE0005.severity = error +dotnet_diagnostic.CS1591.severity = none diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..97a0d68 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,39 @@ +* text=auto + +# Source +*.cs text eol=lf +*.csx text eol=lf + +# Project files +*.csproj text eol=lf +*.props text eol=lf +*.targets text eol=lf +*.sln text eol=crlf + +# Config / docs +*.json text eol=lf +*.jsonc text eol=lf +*.xml text eol=lf +*.config text eol=lf +*.editorconfig text eol=lf +*.gitattributes text eol=lf +*.gitignore text eol=lf +*.md text eol=lf +*.yml text eol=lf +*.yaml text eol=lf + +# Scripts +*.ps1 text eol=crlf +*.bat text eol=crlf +*.cmd text eol=crlf +*.sh text eol=lf + +# Binary assets +*.png binary +*.jpg binary +*.jpeg binary +*.gif binary +*.ico binary +*.pdf binary +*.zip binary +*.dll binary diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..d136fef --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,40 @@ +name: CI + +on: + push: + branches: [ main ] + pull_request: + +permissions: + contents: read + packages: write + +jobs: + format: + uses: PANiXiDA-Infrastructure/ci-cd/.github/workflows/dotnet-format.yml@main + + tests: + uses: PANiXiDA-Infrastructure/ci-cd/.github/workflows/dotnet-tests.yml@main + with: + coverage_assembly_filters: "+PANiXiDA.Core*;-*Tests*" + coverage_threshold: "100" + + publish: + if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }} + needs: + - format + - tests + uses: PANiXiDA-Infrastructure/ci-cd/.github/workflows/dotnet-publish-github-nuget.yml@main + secrets: + GH_PACKAGES_TOKEN: ${{ secrets.GITHUB_TOKEN }} + + notify: + if: ${{ always() && github.event_name != 'pull_request' }} + needs: [ publish ] + uses: PANiXiDA-Infrastructure/ci-cd/.github/workflows/notify-telegram.yml@main + with: + event-name: ${{ github.event_name }} + secrets: + telegram-bot-token: ${{ secrets.TELEGRAM_BOT_TOKEN }} + telegram-chat-id: ${{ vars.TELEGRAM_CHAT_ID }} + github-token: ${{ secrets.REGISTRY_TOKEN }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3fa8e50 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +*.suo +*.user +[Bb]in/ +[Oo]bj/ +.vs/ +.idea +TestResults/ diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..92ff87b --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,88 @@ +# AGENTS.md + +## Purpose + +This repository is a reference template for PANiXiDA .NET NuGet packages. +The goal is to keep package structure, CI, versioning, tests, documentation, and release flow consistent across repositories. + +## Repository layout + +- `src/` — package source code +- `tests/` — automated tests +- `README.md` — package overview and usage examples +- `Directory.Build.props` — shared build settings +- `Directory.Packages.props` — centralized package versions +- `version.json` — Nerdbank.GitVersioning configuration +- `ci.yml` — CI pipeline + +## Technology baseline + +- .NET 10 +- Nullable enabled +- Implicit usings enabled +- Central package management enabled +- Microsoft Testing Platform +- xUnit v3 +- FluentAssertions +- Nerdbank.GitVersioning + +## Coding rules + +- Preserve existing naming. +- Do not introduce expression-bodied method declarations. +- Prefer explicit, readable code over short clever code. +- Public APIs must include XML documentation written in English. +- Avoid breaking public API changes unless explicitly requested. +- Do not weaken nullability annotations. +- Do not silently change exception behavior. + +## Library design rules + +- Keep public API small and intentional. +- Favor immutability for public models. +- Validate all public method arguments. +- Prefer deterministic behavior and stable error messages. +- Do not add dependencies without a strong reason. + +## Tests + +- Add or update tests for every meaningful behavior change. +- Cover happy path, guard clauses, and failure scenarios. +- Verify public API behavior, not implementation details, unless required. +- When fixing a bug, add a regression test first. +- Do not add `using Xunit;` or `using FluentAssertions;` in test files, because they are provided as global usings in the test project. +- Write `DisplayName` values in English. +- Structure tests using the Arrange, Act, Assert pattern. + +## Documentation + +- Update `README.md` when public behavior changes. +- Keep installation, target framework, and examples accurate. +- Keep examples compilable and aligned with the current API. + +## Build and validation + +Before considering work complete, run: + +- `dotnet restore` +- `dotnet format` +- `dotnet build --configuration Release` +- `dotnet test --configuration Release` + +## Packaging and versioning + +- Package metadata must stay complete and consistent. +- README and icon must be included in the package. +- Changes affecting package contents must be reflected in versioning inputs. +- Do not change package id, repository url, or license without explicit request. + +## Definition of done + +A change is done only when: + +- code is formatted, +- code builds, +- tests pass, +- relevant tests were added or updated, +- README was updated if public behavior changed, +- no unnecessary files or dependencies were introduced. diff --git a/Directory.Build.props b/Directory.Build.props new file mode 100644 index 0000000..60634c9 --- /dev/null +++ b/Directory.Build.props @@ -0,0 +1,43 @@ + + + net10.0 + enable + enable + + true + true + true + + true + true + latest + + + + Space App + Space App + git + + true + true + + true + snupkg + + README.md + Apache-2.0 + icon.png + + + + + + + + diff --git a/Directory.Packages.props b/Directory.Packages.props new file mode 100644 index 0000000..1272c60 --- /dev/null +++ b/Directory.Packages.props @@ -0,0 +1,13 @@ + + + true + true + + + + + + + + + diff --git a/PANiXiDA.Core.ResultPattern.slnx b/PANiXiDA.Core.ResultPattern.slnx new file mode 100644 index 0000000..1add422 --- /dev/null +++ b/PANiXiDA.Core.ResultPattern.slnx @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/README.md b/README.md index ce644d8..0a7bf87 100644 --- a/README.md +++ b/README.md @@ -1 +1,656 @@ -# panixida-core-result-pattern \ No newline at end of file +# PANiXiDA.Core.ResultPattern + +`PANiXiDA.Core.ResultPattern` is a small .NET library for explicit success and failure handling in business logic without using exceptions as the primary control-flow contract. + +It is designed for .NET developers who want predictable result-based workflows, typed errors, and composable synchronous and asynchronous operation pipelines. + +## Status + +[![Build](https://img.shields.io/badge/build-passing-brightgreen)](#development) +[![Tests](https://img.shields.io/badge/tests-passing-brightgreen)](#development) +[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](#development) +[![NuGet](https://img.shields.io/badge/NuGet-PANiXiDA.Core.ResultPattern-blue)](#installation) +[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](#license) + +## Overview + +When a method in business logic can end not only with success but also with an expected failure, exceptions often become an awkward contract: + +- the method signature does not show that the method can fail; +- business errors get mixed with technical exceptions; +- the code starts to grow with `try/catch` blocks; +- composing multiple steps becomes harder to read. + +`PANiXiDA.Core.ResultPattern` addresses this by making operation outcomes explicit: + +- `Result` represents success or failure without a value; +- `Result` represents success or failure with a value; +- `Error` provides a unified error model with type, message, and metadata; +- extension methods such as `Map`, `Bind`, `BindAsync`, `Ensure`, `Tap`, and `Match` help compose operation pipelines. + +This library is especially useful in: + +- application services; +- use cases; +- orchestrator layers; +- domain factories and validators; +- API boundaries. + +## Features + +- Explicit success/failure contract with `Result` and `Result` +- Typed error model through `Error` and `ErrorType` +- Support for both single and multiple errors +- Synchronous and asynchronous pipeline composition +- Validation-style workflow support with error aggregation +- Lightweight public API +- XML-documented public API surface +- Suitable for application, domain, and API boundary layers + +## Quick Start + +### Requirements + +- .NET 10 SDK + +### Installation + +The library targets `net10.0`. + +```xml + + + +```` + +### Minimal import + +```csharp +using PANiXiDA.Core.ResultPattern; +``` + +### First example + +```csharp +using PANiXiDA.Core.ResultPattern; + +Result GetUserName(bool exists) +{ + if (!exists) + { + return Result.Failure(Error.NotFound("User not found")); + } + + return Result.Success("John"); +} + +var result = GetUserName(exists: true); + +if (result.IsSuccess) +{ + Console.WriteLine(result.Value); +} +``` + +## Usage + +### Creating errors + +```csharp +using PANiXiDA.Core.ResultPattern; + +var validationError = Error.Validation("Email is required"); +var notFoundError = Error.NotFound("User not found"); +var conflictError = Error.Conflict("Email is already in use"); +var forbiddenError = Error.Forbidden("Insufficient permissions"); + +var fieldError = Error.Validation("Invalid email format") + .WithField("email") + .WithMetadata("attemptedValue", "not-an-email"); +``` + +### `Result` without a value + +```csharp +using PANiXiDA.Core.ResultPattern; + +Result DeleteUser(bool userExists) +{ + if (!userExists) + { + return Result.Failure(Error.NotFound("User not found")); + } + + return Result.Success(); +} +``` + +### `Result` with a value + +```csharp +using PANiXiDA.Core.ResultPattern; + +public sealed record UserDto(Guid Id, string Email); + +Result GetUser(Guid id, UserDto? user) +{ + if (user is null) + { + return Result.Failure(Error.NotFound("User not found")); + } + + return Result.Success(user); +} +``` + +### Checking `IsSuccess` / `IsFailure` and reading `FirstError` + +```csharp +var result = DeleteUser(userExists: false); + +if (result.IsFailure) +{ + Console.WriteLine(result.FirstError.Message); +} +``` + +### `Value`, `ValueOrDefault`, and `TryGetValue` + +```csharp +var userResult = GetUser(Guid.NewGuid(), new UserDto(Guid.NewGuid(), "user@example.com")); + +var value = userResult.Value; +var sameValue = userResult.ValueOrDefault; + +if (userResult.TryGetValue(out var user)) +{ + Console.WriteLine(user.Email); +} +``` + +```csharp +var failedResult = Result.Failure(Error.NotFound("User not found")); + +var defaultValue = failedResult.ValueOrDefault; +var hasValue = failedResult.TryGetValue(out var missingUser); + +Console.WriteLine(defaultValue is null); // True +Console.WriteLine(hasValue); // False +Console.WriteLine(missingUser is null); // True +``` + +### Returning multiple errors + +```csharp +Result ValidateRegistration(string email, string password) +{ + var errors = new List(); + + if (string.IsNullOrWhiteSpace(email)) + { + errors.Add(Error.Validation("Email is required").WithField("email")); + } + + if (string.IsNullOrWhiteSpace(password)) + { + errors.Add(Error.Validation("Password is required").WithField("password")); + } + + if (errors.Count > 0) + { + return Result.Failure(errors); + } + + return Result.Success(); +} +``` + +### `Combine` for joining multiple validations + +```csharp +var emailValidation = ValidateEmail(email); +var passwordValidation = ValidatePassword(password); +var agreementValidation = ValidateAgreement(agreementAccepted); + +var validationResult = Result.Combine( + emailValidation, + passwordValidation, + agreementValidation); + +if (validationResult.IsFailure) +{ + return validationResult; +} +``` + +### `Map` for transforming a result + +`Map` is useful when the source operation is already successful and you only need to transform the value. + +```csharp +Result validationResult = ValidateRegistration(email, password); +Result requestIdResult = validationResult.Map(() => Guid.NewGuid()); +``` + +```csharp +public sealed record User(Guid Id, string Email); +public sealed record UserResponse(Guid Id, string Email); + +Result userResult = Result.Success(new User(Guid.NewGuid(), "user@example.com")); + +Result responseResult = userResult.Map(user => +{ + return new UserResponse(user.Id, user.Email); +}); +``` + +### `Bind` for composing steps that already return `Result` + +`Bind` is useful when the next step can also fail. + +```csharp +Result validationResult = ValidateRegistration(email, password); +Result createUserResult = validationResult.Bind(() => +{ + return CreateUser(email, password); +}); +``` + +```csharp +Result userResult = GetUserById(userId); +Result activationResult = userResult.Bind(ActivateUser); +``` + +```csharp +Result userResult = GetUserById(userId); + +Result responseResult = userResult.Bind(user => +{ + return LoadProfile(user.Id).Map(profile => + { + return new UserResponse(user.Id, user.Email); + }); +}); +``` + +### `BindAsync` for asynchronous composition + +```csharp +Result validationResult = ValidateRegistration(email, password); +Result createUserResult = await validationResult.BindAsync(() => +{ + return CreateUserAsync(email, password); +}); +``` + +```csharp +Result userResult = await GetUserByIdAsync(userId); + +Result responseResult = await userResult.BindAsync(async user => +{ + var profileResult = await LoadProfileAsync(user.Id); + + return profileResult.Map(profile => + { + return new UserResponse(user.Id, user.Email); + }); +}); +``` + +### `Ensure` for additional checks after success + +```csharp +Result userResult = GetUserById(userId); + +Result activeUserResult = userResult + .Ensure( + user => user.IsActive, + Error.Forbidden("User is blocked")) + .Ensure( + user => user.EmailConfirmed, + Error.Validation("Email is not confirmed").WithField("email")); +``` + +### `Tap` for side effects + +`Tap` does not change the result and is useful for logging, auditing, metrics, and other side effects. + +```csharp +Result createResult = CreateUser(email, password); + +Result sameResult = createResult.Tap(user => +{ + Console.WriteLine($"User created: {user.Id}"); +}); +``` + +### `Match` for finishing the pipeline + +`Match` is convenient at the application boundary, when you need to choose the final behavior for success and failure. + +```csharp +Result result = GetUserById(userId) + .Map(user => + { + return new UserResponse(user.Id, user.Email); + }); + +var response = result.Match( + onSuccess: user => + { + return $"200 OK: {user.Email}"; + }, + onFailure: errors => + { + return $"400/404: {string.Join("; ", errors.Select(error => error.Message))}"; + }); +``` + +```csharp +Result deleteResult = DeleteUser(userExists: false); + +var message = deleteResult.Match( + onSuccess: () => + { + return "User deleted"; + }, + onFailure: errors => + { + return $"Deletion failed: {errors[0].Message}"; + }); +``` + +### Full pipeline example + +```csharp +using PANiXiDA.Core.ResultPattern; + +public sealed record RegisterUserCommand(string Email, string Password); +public sealed record User(Guid Id, string Email, bool IsActive, bool EmailConfirmed); +public sealed record UserResponse(Guid Id, string Email); + +public async Task> RegisterAsync(RegisterUserCommand command) +{ + var validationResult = ValidateRegistration(command.Email, command.Password); + var uniqueEmailResult = validationResult.Bind(() => + { + return EnsureEmailIsUnique(command.Email); + }); + + if (uniqueEmailResult.IsFailure) + { + return Result.Failure(uniqueEmailResult.Errors); + } + + var createResult = await uniqueEmailResult.BindAsync(() => + { + return CreateUserAsync(command); + }); + + var guardedResult = createResult + .Ensure(user => user.IsActive, Error.Failure("User was created in an inconsistent state")) + .Ensure(user => user.EmailConfirmed, Error.Validation("Email is not confirmed").WithField("email")) + .Tap(user => + { + Console.WriteLine($"Created user {user.Id}"); + }); + + return guardedResult.Map(user => + { + return new UserResponse(user.Id, user.Email); + }); +} +``` + +### API boundary example + +```csharp +public async Task Register(RegisterUserCommand command) +{ + var result = await RegisterAsync(command); + + return result.Match( + onSuccess: user => + { + return Results.Ok(user); + }, + onFailure: errors => + { + var firstError = errors[0]; + + return firstError.Type switch + { + ErrorType.Validation => Results.BadRequest(errors), + ErrorType.NotFound => Results.NotFound(errors), + ErrorType.Conflict => Results.Conflict(errors), + ErrorType.Unauthorized => Results.Unauthorized(), + ErrorType.Forbidden => Results.StatusCode(StatusCodes.Status403Forbidden), + _ => Results.StatusCode(StatusCodes.Status500InternalServerError) + }; + }); +} +``` + +## Configuration + +This library does not require runtime configuration. + +There are no required: + +* environment variables; +* `appsettings.json` entries; +* secrets; +* ports; +* external services. + +The only consumer-side requirement is referencing the package from a compatible .NET project. + +## Project Structure + +```text +. +├── src/ +│ └── PANiXiDA.Core.ResultPattern/ +│ └── PANiXiDA.Core.ResultPattern.csproj +├── tests/ +│ └── PANiXiDA.Core.ResultPattern.UnitTests/ +│ └── PANiXiDA.Core.ResultPattern.UnitTests.csproj +├── .editorconfig +├── .gitattributes +├── .gitignore +├── Directory.Build.props +├── Directory.Packages.props +├── global.json +├── version.json +├── LICENSE +└── README.md +``` + +### Main repository files + +* `src/` — library source code +* `tests/` — automated tests +* `Directory.Build.props` — shared MSBuild settings +* `Directory.Packages.props` — centralized package versions +* `global.json` — SDK and test runner configuration +* `version.json` — Nerdbank.GitVersioning configuration +* `.editorconfig` — code style rules +* `README.md` — package overview and usage documentation + +## Development + +### Build + +```bash +dotnet restore +dotnet build --configuration Release +``` + +### Format + +```bash +dotnet format +``` + +### Test + +```bash +dotnet test --configuration Release +``` + +### Full local validation + +```bash +dotnet restore +dotnet format +dotnet build --configuration Release +dotnet test --configuration Release +``` + +### Tooling and conventions + +This repository uses: + +* .NET 10 +* Nullable enabled +* Implicit usings enabled +* Central package management +* Microsoft Testing Platform +* xUnit v3 +* FluentAssertions +* Nerdbank.GitVersioning + +## API / Contracts / Examples + +### Core types + +* `Error` — immutable error model with `Message`, `Type`, and `Metadata` +* `ErrorType` — supported error categories: + + * `Validation` + * `NotFound` + * `Conflict` + * `Unauthorized` + * `Forbidden` + * `Failure` + * `Unexpected` +* `Result` — success or failure without a value +* `Result` — success or failure with a value + +### Core operations + +* `Result.Success()` +* `Result.Success(value)` +* `Result.Failure(...)` +* `Result.Combine(...)` +* `Map(...)` +* `Bind(...)` +* `BindAsync(...)` +* `Ensure(...)` +* `Tap(...)` +* `Match(...)` + +### Working with errors + +Factory methods: + +* `Error.Validation(message)` +* `Error.NotFound(message)` +* `Error.Conflict(message)` +* `Error.Unauthorized(message)` +* `Error.Forbidden(message)` +* `Error.Failure(message)` +* `Error.Unexpected(message)` + +Additional helpers: + +* `WithMetadata(key, value)` +* `WithField(field)` + +### Working with values in `Result` + +* `Value` — returns the value on success, otherwise throws `InvalidOperationException` +* `ValueOrDefault` — returns the value on success, or `default` on failure +* `TryGetValue(out value)` — safely attempts to get the value + +### Working with errors in `Result` + +* `Errors` — returns the list of errors +* `FirstError` — returns the first error, otherwise throws `InvalidOperationException` +* `IsSuccess` / `IsFailure` — explicit result state checks + +### Behavioral notes + +* `Value` throws `InvalidOperationException` when the result is a failure. +* `FirstError` throws `InvalidOperationException` when the result is successful. +* `Combine` aggregates errors from all failed results. +* `Match` is intended for finishing a result pipeline at the application boundary. + +## Roadmap / TODO + +Potential future improvements: + +* add more advanced composition helpers if a clear use case appears; +* extend documentation with more domain-oriented examples; +* add dedicated examples for ASP.NET Core minimal APIs; +* add package badges with exact CI and NuGet URLs; +* keep the package as a reusable standard for future PANiXiDA NuGet libraries. + +## Contributing + +Contributions are welcome if they keep the package focused and predictable. + +### General rules + +* keep the public API small and intentional; +* avoid unnecessary dependencies; +* preserve existing naming; +* do not introduce breaking API changes without a strong reason; +* public APIs must have XML documentation in English. + +### Code style + +* follow the repository `.editorconfig`; +* do not introduce expression-bodied method declarations; +* prefer explicit and readable code over overly compact code. + +### Tests + +* add or update tests for every meaningful behavior change; +* cover happy path, guard clauses, and failure scenarios; +* verify public API behavior, not implementation details, unless required; +* add a regression test first when fixing a bug; +* do not add `using Xunit;` or `using FluentAssertions;` in test files, because they are provided as global usings in the test project; +* write `DisplayName` values in English; +* structure tests using the Arrange, Act, Assert pattern. + +### Validation before completion + +Before considering work complete, run: + +```bash +dotnet restore +dotnet format +dotnet build --configuration Release +dotnet test --configuration Release +``` + +## License + +This project is licensed under the Apache License, Version 2.0. + +See the [LICENSE](LICENSE) file for details. + +## Maintainers / Contacts + +Maintained by the PANiXiDA / Space App team. + +Repository: + +* `PANiXiDA-Dotnet-Core/panixida-core-result-pattern` + +For questions or improvements, use: + +* GitHub Issues +* Pull Requests +* repository discussions, if enabled diff --git a/global.json b/global.json new file mode 100644 index 0000000..1d364c6 --- /dev/null +++ b/global.json @@ -0,0 +1,9 @@ +{ + "sdk": { + "version": "10.0.100", + "rollForward": "latestFeature" + }, + "test": { + "runner": "Microsoft.Testing.Platform" + } +} diff --git a/icon.png b/icon.png new file mode 100644 index 0000000000000000000000000000000000000000..0e15a5e15922bb426f3c28d57f5ba23d35a3c765 GIT binary patch literal 416503 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%0AE_v5#VYL!$Aa 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

5tV-wjOHKGEJi}xhDh( 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 i`NsbJ@Dr-OMB;yXzb_89UwZy~LE#e#-w$QG +/// Represents an immutable error returned by an operation result. +/// +public sealed record Error +{ + ///

+ /// The metadata key used to store the field name for validation errors. + /// + public const string FieldMetadataKey = "field"; + + /// + /// Initializes a new instance of . + /// + /// A human-readable error message. + /// The error category. + /// Additional machine-readable error data. + public Error( + string message, + ErrorType type, + IReadOnlyDictionary? metadata = null) + { + if (string.IsNullOrWhiteSpace(message)) + { + throw new ArgumentException("Error message cannot be empty.", nameof(message)); + } + + Message = message; + Type = type; + Metadata = metadata ?? new Dictionary(); + } + + /// + /// Gets the error message. + /// + public string Message { get; } + + /// + /// Gets the error category. + /// + public ErrorType Type { get; } + + /// + /// Gets additional machine-readable error details. + /// + public IReadOnlyDictionary Metadata { get; } + + /// + /// Creates a validation error. + /// + /// The validation error message. + /// A new instance of with type . + public static Error Validation(string message) + { + return new Error(message, ErrorType.Validation); + } + + /// + /// Creates an error for a missing entity or resource. + /// + /// The error message. + /// A new instance of with type . + public static Error NotFound(string message) + { + return new Error(message, ErrorType.NotFound); + } + + /// + /// Creates a state conflict error. + /// + /// The conflict error message. + /// A new instance of with type . + public static Error Conflict(string message) + { + return new Error(message, ErrorType.Conflict); + } + + /// + /// Creates an authorization error. + /// + /// The authorization error message. + /// A new instance of with type . + public static Error Unauthorized(string message) + { + return new Error(message, ErrorType.Unauthorized); + } + + /// + /// Creates an insufficient permissions error. + /// + /// The access error message. + /// A new instance of with type . + public static Error Forbidden(string message) + { + return new Error(message, ErrorType.Forbidden); + } + + /// + /// Creates a business or application failure error. + /// + /// The error message. + /// A new instance of with type . + public static Error Failure(string message) + { + return new Error(message, ErrorType.Failure); + } + + /// + /// Creates an unexpected error. + /// + /// The error message. + /// A new instance of with type . + public static Error Unexpected(string message) + { + return new Error(message, ErrorType.Unexpected); + } + + /// + /// Returns a copy of the current error with an added or replaced metadata entry. + /// + /// The metadata key to add or replace. + /// The metadata value associated with the key. + /// A new instance of with updated metadata. + public Error WithMetadata(string key, object? value) + { + var metadata = new Dictionary(Metadata) + { + [key] = value + }; + + return new Error(Message, Type, metadata); + } + + /// + /// Returns a copy of the current error with the field name stored in metadata. + /// + /// The field name associated with the error. + /// A new instance of with the field metadata populated. + public Error WithField(string field) + { + if (string.IsNullOrWhiteSpace(field)) + { + throw new ArgumentException("Field cannot be empty.", nameof(field)); + } + + return WithMetadata(FieldMetadataKey, field); + } +} diff --git a/src/PANiXiDA.Core.ResultPattern/ErrorType.cs b/src/PANiXiDA.Core.ResultPattern/ErrorType.cs new file mode 100644 index 0000000..7d946a1 --- /dev/null +++ b/src/PANiXiDA.Core.ResultPattern/ErrorType.cs @@ -0,0 +1,42 @@ +namespace PANiXiDA.Core.ResultPattern; + +/// +/// Defines the error categories supported by the library. +/// +public enum ErrorType +{ + /// + /// An input validation error. + /// + Validation = 1, + + /// + /// An error indicating that an entity or resource was not found. + /// + NotFound = 2, + + /// + /// An error indicating a conflict with the current state. + /// + Conflict = 3, + + /// + /// An authorization error. + /// + Unauthorized = 4, + + /// + /// An insufficient permissions error. + /// + Forbidden = 5, + + /// + /// An expected business or application failure. + /// + Failure = 6, + + /// + /// An unexpected error that does not belong to a narrower category. + /// + Unexpected = 7 +} diff --git a/src/PANiXiDA.Core.ResultPattern/GenericResult.cs b/src/PANiXiDA.Core.ResultPattern/GenericResult.cs new file mode 100644 index 0000000..527c891 --- /dev/null +++ b/src/PANiXiDA.Core.ResultPattern/GenericResult.cs @@ -0,0 +1,77 @@ +namespace PANiXiDA.Core.ResultPattern; + +/// +/// Represents the result of an operation that can complete successfully with a value or fail with an error. +/// +/// The type of the successful value. +public sealed class Result : Result +{ + private readonly TValue? value; + + /// + /// Initializes a new successful instance of . + /// + /// The successful value. + internal Result(TValue value) + : base(true, EmptyErrors) + { + this.value = value; + } + + /// + /// Initializes a new failed instance of . + /// + /// Errors associated with the failed result. + internal Result(Error[] errors) + : base(false, errors) + { + value = default; + } + + /// + /// Gets the successful result value. + /// + /// Thrown when the result is a failure. + public TValue Value + { + get + { + if (IsFailure) + { + throw new InvalidOperationException("Cannot access value of failed result."); + } + + return value!; + } + } + + /// + /// Gets the successful value or if the result is a failure. + /// + public TValue? ValueOrDefault + { + get + { + return IsSuccess ? value : default; + } + } + + /// + /// Attempts to get the successful value without throwing an exception. + /// + /// + /// When this method returns, contains the successful value or if the result is a failure. + /// + /// if the result is successful; otherwise, . + public bool TryGetValue(out TValue? resultValue) + { + if (IsSuccess) + { + resultValue = value; + return true; + } + + resultValue = default; + return false; + } +} diff --git a/src/PANiXiDA.Core.ResultPattern/PANiXiDA.Core.ResultPattern.csproj b/src/PANiXiDA.Core.ResultPattern/PANiXiDA.Core.ResultPattern.csproj new file mode 100644 index 0000000..3ce6aec --- /dev/null +++ b/src/PANiXiDA.Core.ResultPattern/PANiXiDA.Core.ResultPattern.csproj @@ -0,0 +1,20 @@ + + + true + + PANiXiDA.Core.ResultPattern + + PANiXiDA.Core.ResultPattern + A library for implementing the Result pattern in .NET applications with typed errors, result composition support, and convenient error handling without exceptions in business logic. + Result;ResultPattern;Errors;Functional;DotNet + + https://github.com/PANiXiDA-Dotnet-Core/panixida-core-result-pattern + https://github.com/PANiXiDA-Dotnet-Core/panixida-core-result-pattern + + + + + all + + + diff --git a/src/PANiXiDA.Core.ResultPattern/Result.cs b/src/PANiXiDA.Core.ResultPattern/Result.cs new file mode 100644 index 0000000..707e136 --- /dev/null +++ b/src/PANiXiDA.Core.ResultPattern/Result.cs @@ -0,0 +1,177 @@ +namespace PANiXiDA.Core.ResultPattern; + +/// +/// Represents the result of an operation that can complete successfully or fail with an error. +/// +public class Result +{ + /// + /// An empty error collection used for successful results. + /// + protected static readonly Error[] EmptyErrors = []; + + /// + /// Initializes a new instance of . + /// + /// Indicates whether the result is successful. + /// Errors associated with the result. + protected Result(bool isSuccess, Error[] errors) + { + if (isSuccess && errors.Length > 0) + { + throw new ArgumentException("Successful result cannot contain errors.", nameof(errors)); + } + + if (!isSuccess && errors.Length == 0) + { + throw new ArgumentException("Failed result must contain at least one error.", nameof(errors)); + } + + IsSuccess = isSuccess; + Errors = errors; + } + + /// + /// Gets a value indicating whether the result is successful. + /// + public bool IsSuccess { get; } + + /// + /// Gets a value indicating whether the result completed with an error. + /// + public bool IsFailure + { + get + { + return !IsSuccess; + } + } + + /// + /// Gets the collection of errors associated with the result. + /// + public IReadOnlyList Errors { get; } + + /// + /// Gets the first error of the result. + /// + /// Thrown when the result is successful. + public Error FirstError + { + get + { + if (IsSuccess) + { + throw new InvalidOperationException("Successful result does not contain errors."); + } + + return Errors[0]; + } + } + + /// + /// Creates a successful result without a value. + /// + /// A successful instance of . + public static Result Success() + { + return new Result(true, EmptyErrors); + } + + /// + /// Creates a successful result with a value. + /// + /// The type of the successful value. + /// The value to wrap in the result. + /// A successful instance of . + public static Result Success(TValue value) + { + return new Result(value); + } + + /// + /// Creates a failed result with a single error. + /// + /// The error associated with the failed result. + /// A failed instance of . + public static Result Failure(Error error) + { + ArgumentNullException.ThrowIfNull(error); + return new Result(false, [error]); + } + + /// + /// Creates a failed result with multiple errors. + /// + /// Errors associated with the failed result. + /// A failed instance of . + public static Result Failure(IEnumerable errors) + { + ArgumentNullException.ThrowIfNull(errors); + + var materializedErrors = errors.Where(item => item is not null).ToArray(); + + if (materializedErrors.Length == 0) + { + throw new ArgumentException("Failed result must contain at least one error.", nameof(errors)); + } + + return new Result(false, materializedErrors); + } + + /// + /// Creates a failed generic result with a single error. + /// + /// The type of the value that would be returned on success. + /// The error associated with the failed result. + /// A failed instance of . + public static Result Failure(Error error) + { + ArgumentNullException.ThrowIfNull(error); + return new Result([error]); + } + + /// + /// Creates a failed generic result with multiple errors. + /// + /// The type of the value that would be returned on success. + /// Errors associated with the failed result. + /// A failed instance of . + public static Result Failure(IEnumerable errors) + { + ArgumentNullException.ThrowIfNull(errors); + + var materializedErrors = errors.Where(static item => item is not null).ToArray(); + + if (materializedErrors.Length == 0) + { + throw new ArgumentException("Failed result must contain at least one error.", nameof(errors)); + } + + return new Result(materializedErrors); + } + + /// + /// Combines multiple results into a single result. + /// + /// The results to combine. + /// + /// A successful result if all provided results are successful; otherwise, a failed result with all collected errors. + /// + public static Result Combine(params Result[] results) + { + ArgumentNullException.ThrowIfNull(results); + + var errors = results + .Where(item => item.IsFailure) + .SelectMany(item => item.Errors) + .ToArray(); + + if (errors.Length == 0) + { + return Success(); + } + + return Failure(errors); + } +} diff --git a/src/PANiXiDA.Core.ResultPattern/ResultCombiner.cs b/src/PANiXiDA.Core.ResultPattern/ResultCombiner.cs new file mode 100644 index 0000000..28a0067 --- /dev/null +++ b/src/PANiXiDA.Core.ResultPattern/ResultCombiner.cs @@ -0,0 +1,393 @@ +namespace PANiXiDA.Core.ResultPattern; + +/// +/// Provides helper methods for combining multiple generic results. +/// +public static class ResultCombiner +{ + /// + /// Combines two generic results into a single tuple result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The first result. + /// The second result. + /// + /// A successful result containing a tuple of values if both results are successful; otherwise, a failed result with all collected errors. + /// + public static Result<(T1, T2)> Combine( + Result first, + Result second) + { + ArgumentNullException.ThrowIfNull(first); + ArgumentNullException.ThrowIfNull(second); + + return CombineCore( + () => Result.Combine(first, second), + () => Result.Success((first.Value, second.Value))); + } + + /// + /// Combines two generic results and continues the successful result with a function that returns another generic result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the continuation result value. + /// The first result. + /// The second result. + /// The continuation function to execute when all results are successful. + /// + /// The result returned by if both results are successful; otherwise, a failed result with all collected errors. + /// + public static Result Combine( + Result first, + Result second, + Func> bind) + { + ArgumentNullException.ThrowIfNull(bind); + + return Combine(first, second) + .Bind(values => bind(values.Item1, values.Item2)); + } + + /// + /// Combines three generic results into a single tuple result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The first result. + /// The second result. + /// The third result. + /// + /// A successful result containing a tuple of values if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result<(T1, T2, T3)> Combine( + Result first, + Result second, + Result third) + { + ArgumentNullException.ThrowIfNull(first); + ArgumentNullException.ThrowIfNull(second); + ArgumentNullException.ThrowIfNull(third); + + return CombineCore( + () => Result.Combine(first, second, third), + () => Result.Success((first.Value, second.Value, third.Value))); + } + + /// + /// Combines three generic results and continues the successful result with a function that returns another generic result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the continuation result value. + /// The first result. + /// The second result. + /// The third result. + /// The continuation function to execute when all results are successful. + /// + /// The result returned by if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result Combine( + Result first, + Result second, + Result third, + Func> bind) + { + ArgumentNullException.ThrowIfNull(bind); + + return Combine(first, second, third) + .Bind(values => bind(values.Item1, values.Item2, values.Item3)); + } + + /// + /// Combines four generic results into a single tuple result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the fourth result value. + /// The first result. + /// The second result. + /// The third result. + /// The fourth result. + /// + /// A successful result containing a tuple of values if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result<(T1, T2, T3, T4)> Combine( + Result first, + Result second, + Result third, + Result fourth) + { + ArgumentNullException.ThrowIfNull(first); + ArgumentNullException.ThrowIfNull(second); + ArgumentNullException.ThrowIfNull(third); + ArgumentNullException.ThrowIfNull(fourth); + + return CombineCore( + () => Result.Combine(first, second, third, fourth), + () => Result.Success((first.Value, second.Value, third.Value, fourth.Value))); + } + + /// + /// Combines four generic results and continues the successful result with a function that returns another generic result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the fourth result value. + /// The type of the continuation result value. + /// The first result. + /// The second result. + /// The third result. + /// The fourth result. + /// The continuation function to execute when all results are successful. + /// + /// The result returned by if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result Combine( + Result first, + Result second, + Result third, + Result fourth, + Func> bind) + { + ArgumentNullException.ThrowIfNull(bind); + + return Combine(first, second, third, fourth) + .Bind(values => bind(values.Item1, values.Item2, values.Item3, values.Item4)); + } + + /// + /// Combines five generic results into a single tuple result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the fourth result value. + /// The type of the fifth result value. + /// The first result. + /// The second result. + /// The third result. + /// The fourth result. + /// The fifth result. + /// + /// A successful result containing a tuple of values if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result<(T1, T2, T3, T4, T5)> Combine( + Result first, + Result second, + Result third, + Result fourth, + Result fifth) + { + ArgumentNullException.ThrowIfNull(first); + ArgumentNullException.ThrowIfNull(second); + ArgumentNullException.ThrowIfNull(third); + ArgumentNullException.ThrowIfNull(fourth); + ArgumentNullException.ThrowIfNull(fifth); + + return CombineCore( + () => Result.Combine(first, second, third, fourth, fifth), + () => Result.Success((first.Value, second.Value, third.Value, fourth.Value, fifth.Value))); + } + + /// + /// Combines five generic results and continues the successful result with a function that returns another generic result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the fourth result value. + /// The type of the fifth result value. + /// The type of the continuation result value. + /// The first result. + /// The second result. + /// The third result. + /// The fourth result. + /// The fifth result. + /// The continuation function to execute when all results are successful. + /// + /// The result returned by if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result Combine( + Result first, + Result second, + Result third, + Result fourth, + Result fifth, + Func> bind) + { + ArgumentNullException.ThrowIfNull(bind); + + return Combine(first, second, third, fourth, fifth) + .Bind(values => bind(values.Item1, values.Item2, values.Item3, values.Item4, values.Item5)); + } + + /// + /// Combines six generic results into a single tuple result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the fourth result value. + /// The type of the fifth result value. + /// The type of the sixth result value. + /// The first result. + /// The second result. + /// The third result. + /// The fourth result. + /// The fifth result. + /// The sixth result. + /// + /// A successful result containing a tuple of values if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result<(T1, T2, T3, T4, T5, T6)> Combine( + Result first, + Result second, + Result third, + Result fourth, + Result fifth, + Result sixth) + { + ArgumentNullException.ThrowIfNull(first); + ArgumentNullException.ThrowIfNull(second); + ArgumentNullException.ThrowIfNull(third); + ArgumentNullException.ThrowIfNull(fourth); + ArgumentNullException.ThrowIfNull(fifth); + ArgumentNullException.ThrowIfNull(sixth); + + return CombineCore( + () => Result.Combine(first, second, third, fourth, fifth, sixth), + () => Result.Success((first.Value, second.Value, third.Value, fourth.Value, fifth.Value, sixth.Value))); + } + + /// + /// Combines six generic results and continues the successful result with a function that returns another generic result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the fourth result value. + /// The type of the fifth result value. + /// The type of the sixth result value. + /// The type of the continuation result value. + /// The first result. + /// The second result. + /// The third result. + /// The fourth result. + /// The fifth result. + /// The sixth result. + /// The continuation function to execute when all results are successful. + /// + /// The result returned by if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result Combine( + Result first, + Result second, + Result third, + Result fourth, + Result fifth, + Result sixth, + Func> bind) + { + ArgumentNullException.ThrowIfNull(bind); + + return Combine(first, second, third, fourth, fifth, sixth) + .Bind(values => bind(values.Item1, values.Item2, values.Item3, values.Item4, values.Item5, values.Item6)); + } + + /// + /// Combines seven generic results into a single tuple result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the fourth result value. + /// The type of the fifth result value. + /// The type of the sixth result value. + /// The type of the seventh result value. + /// The first result. + /// The second result. + /// The third result. + /// The fourth result. + /// The fifth result. + /// The sixth result. + /// The seventh result. + /// + /// A successful result containing a tuple of values if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result<(T1, T2, T3, T4, T5, T6, T7)> Combine( + Result first, + Result second, + Result third, + Result fourth, + Result fifth, + Result sixth, + Result seventh) + { + ArgumentNullException.ThrowIfNull(first); + ArgumentNullException.ThrowIfNull(second); + ArgumentNullException.ThrowIfNull(third); + ArgumentNullException.ThrowIfNull(fourth); + ArgumentNullException.ThrowIfNull(fifth); + ArgumentNullException.ThrowIfNull(sixth); + ArgumentNullException.ThrowIfNull(seventh); + + return CombineCore( + () => Result.Combine(first, second, third, fourth, fifth, sixth, seventh), + () => Result.Success((first.Value, second.Value, third.Value, fourth.Value, fifth.Value, sixth.Value, seventh.Value))); + } + + /// + /// Combines seven generic results and continues the successful result with a function that returns another generic result. + /// + /// The type of the first result value. + /// The type of the second result value. + /// The type of the third result value. + /// The type of the fourth result value. + /// The type of the fifth result value. + /// The type of the sixth result value. + /// The type of the seventh result value. + /// The type of the continuation result value. + /// The first result. + /// The second result. + /// The third result. + /// The fourth result. + /// The fifth result. + /// The sixth result. + /// The seventh result. + /// The continuation function to execute when all results are successful. + /// + /// The result returned by if all results are successful; otherwise, a failed result with all collected errors. + /// + public static Result Combine( + Result first, + Result second, + Result third, + Result fourth, + Result fifth, + Result sixth, + Result seventh, + Func> bind) + { + ArgumentNullException.ThrowIfNull(bind); + + return Combine(first, second, third, fourth, fifth, sixth, seventh) + .Bind(values => bind(values.Item1, values.Item2, values.Item3, values.Item4, values.Item5, values.Item6, values.Item7)); + } + + private static Result CombineCore(Func combine, Func> bind) + { + var combinedResult = combine(); + if (combinedResult.IsFailure) + { + return Result.Failure(combinedResult.Errors); + } + + return bind(); + } +} diff --git a/src/PANiXiDA.Core.ResultPattern/ResultExtensions.cs b/src/PANiXiDA.Core.ResultPattern/ResultExtensions.cs new file mode 100644 index 0000000..ad7986e --- /dev/null +++ b/src/PANiXiDA.Core.ResultPattern/ResultExtensions.cs @@ -0,0 +1,250 @@ +namespace PANiXiDA.Core.ResultPattern; + +/// +/// Provides helper methods for composing and transforming and . +/// +public static class ResultExtensions +{ + /// + /// Transforms a successful non-generic result into a successful generic result. + /// + /// The type of the resulting value. + /// The source result. + /// The mapping function to execute on success. + /// + /// A successful with the transformed value, or a failed result with the source result errors preserved. + /// + public static Result Map(this Result result, Func map) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(map); + + if (result.IsFailure) + { + return Result.Failure(result.Errors); + } + + return Result.Success(map()); + } + + /// + /// Transforms a successful generic result into another successful generic result. + /// + /// The type of the source value. + /// The type of the resulting value. + /// The source result. + /// The mapping function to execute on success. + /// + /// A successful with the transformed value, or a failed result with the source result errors preserved. + /// + public static Result Map(this Result result, Func map) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(map); + + if (result.IsFailure) + { + return Result.Failure(result.Errors); + } + + return Result.Success(map(result.Value)); + } + + /// + /// Continues a successful generic result with a function that returns a non-generic result. + /// + /// The type of the source value. + /// The source result. + /// The continuation function to execute on success. + /// + /// The result returned by if the source result is successful; otherwise, a failed result with the source result errors preserved. + /// + public static Result Bind(this Result result, Func bind) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(bind); + + if (result.IsFailure) + { + return Result.Failure(result.Errors); + } + + return bind(result.Value); + } + + /// + /// Continues a successful generic result with a function that returns another generic result. + /// + /// The type of the source value. + /// The type of the continuation result value. + /// The source result. + /// The continuation function to execute on success. + /// + /// The result returned by if the source result is successful; otherwise, a failed result with the source result errors preserved. + /// + public static Result Bind(this Result result, Func> bind) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(bind); + + if (result.IsFailure) + { + return Result.Failure(result.Errors); + } + + return bind(result.Value); + } + + /// + /// Continues a successful non-generic result with a function that returns a generic result. + /// + /// The type of the continuation result value. + /// The source result. + /// The continuation function to execute on success. + /// + /// The result returned by if the source result is successful; otherwise, a failed result with the source result errors preserved. + /// + public static Result Bind(this Result result, Func> bind) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(bind); + + if (result.IsFailure) + { + return Result.Failure(result.Errors); + } + + return bind(); + } + + /// + /// Asynchronously continues a successful generic result with a function that returns a generic result. + /// + /// The type of the source value. + /// The type of the continuation result value. + /// The source result. + /// The asynchronous continuation function to execute on success. + /// + /// A task returning the result of if the source result is successful; otherwise, a failed result with the source result errors preserved. + /// + public static Task> BindAsync(this Result result, Func>> bind) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(bind); + + if (result.IsFailure) + { + return Task.FromResult(Result.Failure(result.Errors)); + } + + return bind(result.Value); + } + + /// + /// Asynchronously continues a successful non-generic result with a function that returns a generic result. + /// + /// The type of the continuation result value. + /// The source result. + /// The asynchronous continuation function to execute on success. + /// + /// A task returning the result of if the source result is successful; otherwise, a failed result with the source result errors preserved. + /// + public static Task> BindAsync(this Result result, Func>> bind) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(bind); + + if (result.IsFailure) + { + return Task.FromResult(Result.Failure(result.Errors)); + } + + return bind(); + } + + /// + /// Validates a successful generic result with an additional predicate. + /// + /// The type of the source value. + /// The source result. + /// The predicate that must return for the result to remain successful. + /// The error returned when the predicate fails. + /// + /// The source result if it is already failed or if the predicate succeeds; otherwise, a failed result with the error. + /// + public static Result Ensure(this Result result, Func predicate, Error error) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(predicate); + ArgumentNullException.ThrowIfNull(error); + + if (result.IsFailure) + { + return result; + } + + return predicate(result.Value) + ? result + : Result.Failure(error); + } + + /// + /// Executes a side effect for a successful generic result and returns the original result. + /// + /// The type of the source value. + /// The source result. + /// The side effect to execute on success. + /// The source result. + public static Result Tap(this Result result, Action action) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(action); + + if (result.IsFailure) + { + return result; + } + + action(result.Value); + return result; + } + + /// + /// Converts a non-generic result into a final value by handling both success and failure. + /// + /// The type of the final value. + /// The source result. + /// The function to execute on success. + /// The function to execute on failure. + /// The value returned by the matching branch. + public static TOut Match(this Result result, Func onSuccess, Func, TOut> onFailure) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(onSuccess); + ArgumentNullException.ThrowIfNull(onFailure); + + return result.IsSuccess + ? onSuccess() + : onFailure(result.Errors); + } + + /// + /// Converts a generic result into a final value by handling both success and failure. + /// + /// The type of the source value. + /// The type of the final value. + /// The source result. + /// The function to execute on success. + /// The function to execute on failure. + /// The value returned by the matching branch. + public static TOut Match(this Result result, Func onSuccess, Func, TOut> onFailure) + { + ArgumentNullException.ThrowIfNull(result); + ArgumentNullException.ThrowIfNull(onSuccess); + ArgumentNullException.ThrowIfNull(onFailure); + + return result.IsSuccess + ? onSuccess(result.Value) + : onFailure(result.Errors); + } +} diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs new file mode 100644 index 0000000..e061fe0 --- /dev/null +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs @@ -0,0 +1,244 @@ +namespace PANiXiDA.Core.ResultPattern.UnitTests; + +public sealed class ErrorTests +{ + [Fact(DisplayName = "Error ctor → sets properties when valid message, type, and metadata are provided")] + public void Constructor_Should_SetProperties_When_MessageTypeAndMetadataAreValid() + { + const string message = "Validation failed"; + const string metadataKey = "code"; + const int metadataValue = 42; + var metadata = new Dictionary + { + [metadataKey] = metadataValue + }; + + var error = new Error(message, ErrorType.Validation, metadata); + + error.Message.Should().Be(message); + error.Type.Should().Be(ErrorType.Validation); + error.Metadata.Should().ContainSingle() + .Which.Should().Be(new KeyValuePair(metadataKey, metadataValue)); + error.Metadata.Should().BeSameAs(metadata); + } + + [Fact(DisplayName = "Error ctor → creates empty metadata when metadata is not provided")] + public void Constructor_Should_InitializeEmptyMetadata_When_MetadataIsNull() + { + const string message = "Validation failed"; + + var error = new Error(message, ErrorType.Validation); + + error.Metadata.Should().BeEmpty(); + } + + [Fact(DisplayName = "Error ctor → throws ArgumentException when message is null")] + public void Constructor_Should_ThrowArgumentException_When_MessageIsNull() + { + Action act = static () => _ = new Error(null!, ErrorType.Validation); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("message"); + } + + [Fact(DisplayName = "Error ctor → throws ArgumentException when message is empty")] + public void Constructor_Should_ThrowArgumentException_When_MessageIsEmpty() + { + Action act = () => _ = new Error(string.Empty, ErrorType.Validation); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("message"); + } + + [Fact(DisplayName = "Error ctor → throws ArgumentException when message contains only whitespace")] + public void Constructor_Should_ThrowArgumentException_When_MessageIsWhitespace() + { + Action act = () => _ = new Error(" ", ErrorType.Validation); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("message"); + } + + [Fact(DisplayName = "Validation → returns a Validation error when a message is provided")] + public void Validation_Should_ReturnValidationError_When_MessageIsProvided() + { + const string message = "Validation failed"; + + var error = Error.Validation(message); + + AssertError(error, message, ErrorType.Validation); + } + + [Fact(DisplayName = "NotFound → returns a NotFound error when a message is provided")] + public void NotFound_Should_ReturnNotFoundError_When_MessageIsProvided() + { + const string message = "Entity not found"; + + var error = Error.NotFound(message); + + AssertError(error, message, ErrorType.NotFound); + } + + [Fact(DisplayName = "Conflict → returns a Conflict error when a message is provided")] + public void Conflict_Should_ReturnConflictError_When_MessageIsProvided() + { + const string message = "Entity already exists"; + + var error = Error.Conflict(message); + + AssertError(error, message, ErrorType.Conflict); + } + + [Fact(DisplayName = "Unauthorized → returns an Unauthorized error when a message is provided")] + public void Unauthorized_Should_ReturnUnauthorizedError_When_MessageIsProvided() + { + const string message = "Authentication required"; + + var error = Error.Unauthorized(message); + + AssertError(error, message, ErrorType.Unauthorized); + } + + [Fact(DisplayName = "Forbidden → returns a Forbidden error when a message is provided")] + public void Forbidden_Should_ReturnForbiddenError_When_MessageIsProvided() + { + const string message = "Access denied"; + + var error = Error.Forbidden(message); + + AssertError(error, message, ErrorType.Forbidden); + } + + [Fact(DisplayName = "Failure → returns a Failure error when a message is provided")] + public void Failure_Should_ReturnFailureError_When_MessageIsProvided() + { + const string message = "Operation failed"; + + var error = Error.Failure(message); + + AssertError(error, message, ErrorType.Failure); + } + + [Fact(DisplayName = "Unexpected → returns an Unexpected error when a message is provided")] + public void Unexpected_Should_ReturnUnexpectedError_When_MessageIsProvided() + { + const string message = "Unexpected error"; + + var error = Error.Unexpected(message); + + AssertError(error, message, ErrorType.Unexpected); + } + + [Fact(DisplayName = "WithMetadata → adds new metadata when the key does not exist")] + public void WithMetadata_Should_AddMetadata_When_KeyDoesNotExist() + { + const string message = "Validation failed"; + var key = Error.FieldMetadataKey; + const string value = "name"; + var error = Error.Validation(message); + + var updatedError = error.WithMetadata(key, value); + + updatedError.Metadata.Should().ContainSingle() + .Which.Should().Be(new KeyValuePair(key, value)); + } + + [Fact(DisplayName = "WithMetadata → overwrites metadata when the key already exists")] + public void WithMetadata_Should_OverrideMetadata_When_KeyAlreadyExists() + { + var key = Error.FieldMetadataKey; + const string message = "Validation failed"; + const string originalValue = "old-name"; + const string updatedValue = "new-name"; + var error = new Error( + message, + ErrorType.Validation, + new Dictionary { [key] = originalValue }); + + var updatedError = error.WithMetadata(key, updatedValue); + + updatedError.Metadata.Should().ContainSingle() + .Which.Should().Be(new KeyValuePair(key, updatedValue)); + } + + [Fact(DisplayName = "WithMetadata → returns a new error and does not modify the original when metadata is updated")] + public void WithMetadata_Should_ReturnNewErrorWithoutMutatingOriginal_When_MetadataIsUpdated() + { + var key = Error.FieldMetadataKey; + const string message = "Validation failed"; + const string originalValue = "old-name"; + const string metadataKey = "code"; + const int metadataValue = 100; + var error = new Error( + message, + ErrorType.Validation, + new Dictionary { [key] = originalValue }); + + var updatedError = error.WithMetadata(metadataKey, metadataValue); + + updatedError.Should().NotBeSameAs(error); + + error.Metadata.Should().ContainSingle() + .Which.Should().Be(new KeyValuePair(key, originalValue)); + + updatedError.Metadata.Should().HaveCount(2); + updatedError.Metadata.Should().Contain(new KeyValuePair(key, originalValue)); + updatedError.Metadata.Should().Contain(new KeyValuePair(metadataKey, metadataValue)); + } + + [Fact(DisplayName = "WithField → adds field metadata when a valid field name is provided")] + public void WithField_Should_AddFieldMetadata_When_FieldIsValid() + { + const string message = "Validation failed"; + const string field = "name"; + var error = Error.Validation(message); + + var updatedError = error.WithField(field); + + updatedError.Metadata.Should().ContainSingle() + .Which.Should().Be(new KeyValuePair(Error.FieldMetadataKey, field)); + } + + [Fact(DisplayName = "WithField → throws ArgumentException when field is null")] + public void WithField_Should_ThrowArgumentException_When_FieldIsNull() + { + var error = Error.Validation("Validation failed"); + Action act = () => error.WithField(null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("field"); + } + + [Fact(DisplayName = "WithField → throws ArgumentException when field is empty")] + public void WithField_Should_ThrowArgumentException_When_FieldIsEmpty() + { + var error = Error.Validation("Validation failed"); + Action act = () => error.WithField(string.Empty); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("field"); + } + + [Fact(DisplayName = "WithField → throws ArgumentException when field contains only whitespace")] + public void WithField_Should_ThrowArgumentException_When_FieldIsWhitespace() + { + var error = Error.Validation("Validation failed"); + Action act = () => error.WithField(" "); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("field"); + } + + private static void AssertError(Error error, string expectedMessage, ErrorType expectedType) + { + error.Message.Should().Be(expectedMessage); + error.Type.Should().Be(expectedType); + error.Metadata.Should().BeEmpty(); + } +} diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/GenericResultTests.cs b/tests/PANiXiDA.Core.ResultPattern.UnitTests/GenericResultTests.cs new file mode 100644 index 0000000..26bef24 --- /dev/null +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/GenericResultTests.cs @@ -0,0 +1,166 @@ +namespace PANiXiDA.Core.ResultPattern.UnitTests; + +public sealed class GenericResultTests +{ + [Fact(DisplayName = "Success → returns a successful generic result when a value is provided")] + public void Success_Should_ReturnSuccessfulGenericResult_When_ValueIsProvided() + { + const int value = 42; + + var result = Result.Success(value); + + result.IsSuccess.Should().BeTrue(); + result.IsFailure.Should().BeFalse(); + result.Errors.Should().BeEmpty(); + result.Value.Should().Be(value); + } + + [Fact(DisplayName = "Success → returns a successful generic result when null is provided")] + public void Success_Should_ReturnSuccessfulGenericResult_When_ValueIsNull() + { + string? value = null; + + var result = Result.Success(value); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().BeNull(); + result.ValueOrDefault.Should().BeNull(); + } + + [Fact(DisplayName = "Value → returns the value when the result is successful")] + public void Value_Should_ReturnValue_When_ResultIsSuccess() + { + const string value = "value"; + + var result = Result.Success(value); + + result.Value.Should().Be(value); + } + + [Fact(DisplayName = "Value → throws InvalidOperationException when the result is a failure")] + public void Value_Should_ThrowInvalidOperationException_When_ResultIsFailure() + { + var result = Result.Failure(Error.Validation("Validation failed")); + Action act = () => _ = result.Value; + + var exception = act.Should().Throw().Which; + + exception.Message.Should().Be("Cannot access value of failed result."); + } + + [Fact(DisplayName = "ValueOrDefault → returns the value when the result is successful")] + public void ValueOrDefault_Should_ReturnValue_When_ResultIsSuccess() + { + const string value = "value"; + + var result = Result.Success(value); + + result.ValueOrDefault.Should().Be(value); + } + + [Fact(DisplayName = "ValueOrDefault → returns default when the result is a failure")] + public void ValueOrDefault_Should_ReturnDefault_When_ResultIsFailure() + { + var result = Result.Failure(Error.Validation("Validation failed")); + + var value = result.ValueOrDefault; + + value.Should().BeNull(); + } + + [Fact(DisplayName = "TryGetValue → returns true and the value when the result is successful")] + public void TryGetValue_Should_ReturnTrueAndValue_When_ResultIsSuccess() + { + const string value = "value"; + var result = Result.Success(value); + + var success = result.TryGetValue(out var actualValue); + + success.Should().BeTrue(); + actualValue.Should().Be(value); + } + + [Fact(DisplayName = "TryGetValue → returns false and default when the result is a failure")] + public void TryGetValue_Should_ReturnFalseAndDefault_When_ResultIsFailure() + { + var result = Result.Failure(Error.Validation("Validation failed")); + + var success = result.TryGetValue(out var value); + + success.Should().BeFalse(); + value.Should().BeNull(); + } + + [Fact(DisplayName = "Failure(Error) → returns a failed generic result when an error is provided")] + public void Failure_Should_ReturnFailureGenericResult_When_ErrorIsProvided() + { + var error = Error.Validation("Validation failed"); + + var result = Result.Failure(error); + + result.IsFailure.Should().BeTrue(); + result.Errors.Should().ContainSingle().Which.Should().BeSameAs(error); + } + + [Fact(DisplayName = "Failure(Error) → throws ArgumentNullException when error is null")] + public void Failure_Should_ThrowArgumentNullException_When_ErrorIsNull() + { + Action act = () => Result.Failure((Error)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("error"); + } + + [Fact(DisplayName = "Failure(IEnumerable) → returns a failed generic result when the collection contains errors")] + public void Failure_Should_ReturnFailureGenericResult_When_ErrorCollectionContainsErrors() + { + var firstError = Error.Validation("Validation failed"); + var secondError = Error.NotFound("Not found"); + + var result = Result.Failure([firstError, secondError]); + + result.IsFailure.Should().BeTrue(); + result.Errors.Should().Equal(firstError, secondError); + } + + [Fact(DisplayName = "Failure(IEnumerable) → filters out null values when the collection contains null")] + public void Failure_Should_FilterOutNullErrors_When_ErrorCollectionContainsNullValues() + { + var error = Error.Validation("Validation failed"); + + var result = Result.Failure([error, null!]); + + result.Errors.Should().ContainSingle().Which.Should().BeSameAs(error); + } + + [Fact(DisplayName = "Failure(IEnumerable) → throws ArgumentNullException when the error collection is null")] + public void Failure_Should_ThrowArgumentNullException_When_ErrorCollectionIsNull() + { + Action act = () => Result.Failure((IEnumerable)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("errors"); + } + + [Fact(DisplayName = "Failure(IEnumerable) → throws ArgumentException when the error collection is empty")] + public void Failure_Should_ThrowArgumentException_When_ErrorCollectionIsEmpty() + { + Action act = () => Result.Failure([]); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("errors"); + } + + [Fact(DisplayName = "Failure(IEnumerable) → throws ArgumentException when the collection contains only null")] + public void Failure_Should_ThrowArgumentException_When_ErrorCollectionContainsOnlyNullValues() + { + Action act = () => Result.Failure([null!]); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("errors"); + } +} diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/PANiXiDA.Core.ResultPattern.UnitTests.csproj b/tests/PANiXiDA.Core.ResultPattern.UnitTests/PANiXiDA.Core.ResultPattern.UnitTests.csproj new file mode 100644 index 0000000..b6ae9de --- /dev/null +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/PANiXiDA.Core.ResultPattern.UnitTests.csproj @@ -0,0 +1,21 @@ + + + Exe + + + + + + + + + + + + + + + + + + diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultCombinerTests.cs b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultCombinerTests.cs new file mode 100644 index 0000000..7d8a796 --- /dev/null +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultCombinerTests.cs @@ -0,0 +1,346 @@ +namespace PANiXiDA.Core.ResultPattern.UnitTests; + +public sealed class ResultCombinerTests +{ + [Fact(DisplayName = "Combine(Result, Result) → returns a tuple result when both results are successful")] + public void TupleCombine2_Should_ReturnTuple_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + + var result = ResultCombiner.Combine(first, second); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be((1, 2)); + } + + [Fact(DisplayName = "Combine(Result, Result) → throws ArgumentNullException when the first result is null")] + public void TupleCombine2_Should_ThrowArgumentNullException_When_FirstIsNull() + { + Action act = () => ResultCombiner.Combine( + null!, + Result.Success(2)); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("first"); + } + + [Fact(DisplayName = "Combine(Result, Result, Result) → returns a tuple result when all results are successful")] + public void TupleCombine3_Should_ReturnTuple_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + var third = Result.Success(3); + + var result = ResultCombiner.Combine(first, second, third); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be((1, 2, 3)); + } + + [Fact(DisplayName = "Combine(Result, Result, Result) → returns a failure with aggregated errors when the results contain errors")] + public void TupleCombine3_Should_ReturnFailure_When_AnyResultIsFailure() + { + var firstError = Error.Validation("first"); + var secondError = Error.Conflict("second"); + + var first = Result.Failure(firstError); + var second = Result.Success(2); + var third = Result.Failure(secondError); + + var result = ResultCombiner.Combine(first, second, third); + + result.IsFailure.Should().BeTrue(); + result.Errors.Should().Equal(firstError, secondError); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result) → returns a tuple result when all results are successful")] + public void TupleCombine4_Should_ReturnTuple_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + var third = Result.Success(3); + var fourth = Result.Success(4); + + var result = ResultCombiner.Combine(first, second, third, fourth); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be((1, 2, 3, 4)); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result, Result) → returns a tuple result when all results are successful")] + public void TupleCombine5_Should_ReturnTuple_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + var third = Result.Success(3); + var fourth = Result.Success(4); + var fifth = Result.Success(5); + + var result = ResultCombiner.Combine(first, second, third, fourth, fifth); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be((1, 2, 3, 4, 5)); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result, Result, Result) → returns a tuple result when all results are successful")] + public void TupleCombine6_Should_ReturnTuple_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + var third = Result.Success(3); + var fourth = Result.Success(4); + var fifth = Result.Success(5); + var sixth = Result.Success(6); + + var result = ResultCombiner.Combine(first, second, third, fourth, fifth, sixth); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be((1, 2, 3, 4, 5, 6)); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result, Result, Result, Result) → returns a tuple result preserving the original value order")] + public void TupleCombine7_Should_ReturnTupleInOriginalOrder_When_AllResultsAreSuccessful() + { + var first = Result.Success("1"); + var second = Result.Success("2"); + var third = Result.Success("3"); + var fourth = Result.Success("4"); + var fifth = Result.Success("5"); + var sixth = Result.Success("6"); + var seventh = Result.Success("7"); + + var result = ResultCombiner.Combine(first, second, third, fourth, fifth, sixth, seventh); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be(("1", "2", "3", "4", "5", "6", "7")); + } + + [Fact(DisplayName = "Combine(Result, Result, Func>) → returns the bind result when both results are successful")] + public void Combine2_Should_ReturnBindResult_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + + var result = ResultCombiner.Combine( + first, + second, + static (firstValue, secondValue) => Result.Success(firstValue + secondValue)); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be(3); + } + + [Fact(DisplayName = "Combine(Result, Result, Func>) → throws ArgumentNullException when the first result is null")] + public void Combine2_Should_ThrowArgumentNullException_When_FirstIsNull() + { + Action act = () => ResultCombiner.Combine( + null!, + Result.Success(2), + static (first, second) => Result.Success(first + second)); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("first"); + } + + [Fact(DisplayName = "Combine(Result, Result, Func>) → throws ArgumentNullException when bind is null")] + public void Combine2_Should_ThrowArgumentNullException_When_BindIsNull() + { + Action act = () => ResultCombiner.Combine( + Result.Success(1), + Result.Success(2), + (Func>)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("bind"); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Func>) → returns the bind result when all results are successful")] + public void Combine3_Should_ReturnBindResult_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + var third = Result.Success(3); + + var result = ResultCombiner.Combine( + first, + second, + third, + static (firstValue, secondValue, thirdValue) => Result.Success(firstValue + secondValue + thirdValue)); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be(6); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Func>) → returns failure without invoking bind when the results contain errors")] + public void Combine3_Should_ReturnFailureWithoutInvokingBind_When_AnyResultIsFailure() + { + var firstError = Error.Validation("first"); + var secondError = Error.Conflict("second"); + var wasInvoked = false; + + var first = Result.Failure(firstError); + var second = Result.Success(2); + var third = Result.Failure(secondError); + + var result = ResultCombiner.Combine( + first, + second, + third, + (firstValue, secondValue, thirdValue) => + { + wasInvoked = true; + return Result.Success(firstValue + secondValue + thirdValue); + }); + + wasInvoked.Should().BeFalse(); + result.IsFailure.Should().BeTrue(); + result.Errors.Should().Equal(firstError, secondError); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result, Func>) → returns the bind result when all results are successful")] + public void Combine4_Should_ReturnBindResult_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + var third = Result.Success(3); + var fourth = Result.Success(4); + + var result = ResultCombiner.Combine( + first, + second, + third, + fourth, + static (firstValue, secondValue, thirdValue, fourthValue) => + Result.Success(firstValue + secondValue + thirdValue + fourthValue)); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be(10); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result, Result, Func>) → returns the bind result when all results are successful")] + public void Combine5_Should_ReturnBindResult_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + var third = Result.Success(3); + var fourth = Result.Success(4); + var fifth = Result.Success(5); + + var result = ResultCombiner.Combine( + first, + second, + third, + fourth, + fifth, + static (firstValue, secondValue, thirdValue, fourthValue, fifthValue) => + Result.Success(firstValue + secondValue + thirdValue + fourthValue + fifthValue)); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be(15); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result, Result, Result, Func>) → returns the bind result when all results are successful")] + public void Combine6_Should_ReturnBindResult_When_AllResultsAreSuccessful() + { + var first = Result.Success(1); + var second = Result.Success(2); + var third = Result.Success(3); + var fourth = Result.Success(4); + var fifth = Result.Success(5); + var sixth = Result.Success(6); + + var result = ResultCombiner.Combine( + first, + second, + third, + fourth, + fifth, + sixth, + static (firstValue, secondValue, thirdValue, fourthValue, fifthValue, sixthValue) => + Result.Success(firstValue + secondValue + thirdValue + fourthValue + fifthValue + sixthValue)); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be(21); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result, Result, Result, Result, Func>) → passes values to bind in the original order")] + public void Combine7_Should_PassValuesInOrderToBind_When_AllResultsAreSuccessful() + { + var first = Result.Success("1"); + var second = Result.Success("2"); + var third = Result.Success("3"); + var fourth = Result.Success("4"); + var fifth = Result.Success("5"); + var sixth = Result.Success("6"); + var seventh = Result.Success("7"); + + var result = ResultCombiner.Combine( + first, + second, + third, + fourth, + fifth, + sixth, + seventh, + static (firstValue, secondValue, thirdValue, fourthValue, fifthValue, sixthValue, seventhValue) => + { + return Result.Success(string.Concat( + firstValue, + secondValue, + thirdValue, + fourthValue, + fifthValue, + sixthValue, + seventhValue)); + }); + + result.IsSuccess.Should().BeTrue(); + result.Value.Should().Be("1234567"); + } + + [Fact(DisplayName = "Combine(Result, Result, Result, Result, Result, Result, Result, Func>) → returns failure without invoking bind when the results contain errors")] + public void Combine7_Should_ReturnFailureWithoutInvokingBind_When_AnyResultIsFailure() + { + var firstError = Error.Validation("first"); + var secondError = Error.NotFound("second"); + var thirdError = Error.Conflict("third"); + var wasInvoked = false; + + var first = Result.Success(1); + var second = Result.Failure(firstError); + var third = Result.Success(3); + var fourth = Result.Failure(secondError); + var fifth = Result.Success(5); + var sixth = Result.Failure(thirdError); + var seventh = Result.Success(7); + + var result = ResultCombiner.Combine( + first, + second, + third, + fourth, + fifth, + sixth, + seventh, + (firstValue, secondValue, thirdValue, fourthValue, fifthValue, sixthValue, seventhValue) => + { + wasInvoked = true; + return Result.Success( + firstValue + + secondValue + + thirdValue + + fourthValue + + fifthValue + + sixthValue + + seventhValue); + }); + + wasInvoked.Should().BeFalse(); + result.IsFailure.Should().BeTrue(); + result.Errors.Should().Equal(firstError, secondError, thirdError); + } +} diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultExtensionsTests.cs b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultExtensionsTests.cs new file mode 100644 index 0000000..9606e6b --- /dev/null +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultExtensionsTests.cs @@ -0,0 +1,643 @@ +namespace PANiXiDA.Core.ResultPattern.UnitTests; + +public sealed class ResultExtensionsTests +{ + [Fact(DisplayName = "Map(Result, Func) → throws ArgumentNullException when result is null")] + public void Map_Should_ThrowArgumentNullException_When_ResultIsNull() + { + Action act = () => ResultExtensions.Map(null!, () => 1); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Map(Result, Func) → throws ArgumentNullException when map is null")] + public void Map_Should_ThrowArgumentNullException_When_MapIsNull() + { + var result = Result.Success(); + Action act = () => result.Map((Func)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("map"); + } + + [Fact(DisplayName = "Map(Result, Func) → returns mapped result when the source result is successful")] + public void Map_Should_ReturnMappedResult_When_ResultIsSuccess() + { + const int expectedValue = 42; + var result = Result.Success(); + + var mappedResult = result.Map(() => expectedValue); + + mappedResult.IsSuccess.Should().BeTrue(); + mappedResult.Value.Should().Be(expectedValue); + } + + [Fact(DisplayName = "Map(Result, Func) → returns failure without invoking mapper when the source result is a failure")] + public void Map_Should_ReturnFailureWithoutInvokingMapper_When_ResultIsFailure() + { + var sourceError = Error.Validation("Validation failed"); + var result = Result.Failure(sourceError); + var wasInvoked = false; + + var mappedResult = result.Map(() => + { + wasInvoked = true; + return 42; + }); + + wasInvoked.Should().BeFalse(); + mappedResult.IsFailure.Should().BeTrue(); + mappedResult.Errors.Should().ContainSingle().Which.Should().BeSameAs(sourceError); + } + + [Fact(DisplayName = "Map(Result, Func) → throws ArgumentNullException when result is null")] + public void Map_Should_ThrowArgumentNullException_When_GenericResultIsNull() + { + Action act = () => ResultExtensions.Map(null!, value => value.Length); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Map(Result, Func) → throws ArgumentNullException when map is null")] + public void Map_Should_ThrowArgumentNullException_When_GenericMapIsNull() + { + var result = Result.Success("value"); + Action act = () => result.Map((Func)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("map"); + } + + [Fact(DisplayName = "Map(Result, Func) → returns mapped result when the source generic result is successful")] + public void Map_Should_ReturnMappedResult_When_GenericResultIsSuccess() + { + const string value = "value"; + var result = Result.Success(value); + + var mappedResult = result.Map(item => item.Length); + + mappedResult.IsSuccess.Should().BeTrue(); + mappedResult.Value.Should().Be(value.Length); + } + + [Fact(DisplayName = "Map(Result, Func) → returns failure without invoking mapper when the source generic result is a failure")] + public void Map_Should_ReturnFailureWithoutInvokingMapper_When_GenericResultIsFailure() + { + var sourceError = Error.Validation("Validation failed"); + var result = Result.Failure(sourceError); + var wasInvoked = false; + + var mappedResult = result.Map(value => + { + wasInvoked = true; + return value.Length; + }); + + wasInvoked.Should().BeFalse(); + mappedResult.IsFailure.Should().BeTrue(); + mappedResult.Errors.Should().ContainSingle().Which.Should().BeSameAs(sourceError); + } + + [Fact(DisplayName = "Bind(Result, Func) → throws ArgumentNullException when result is null")] + public void Bind_Should_ThrowArgumentNullException_When_ResultIsNull() + { + Action act = () => ResultExtensions.Bind(null!, value => Result.Success()); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Bind(Result, Func) → throws ArgumentNullException when bind is null")] + public void Bind_Should_ThrowArgumentNullException_When_BindIsNull() + { + var result = Result.Success("value"); + Action act = () => result.Bind((Func)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("bind"); + } + + [Fact(DisplayName = "Bind(Result, Func) → returns the bind result when the source generic result is successful")] + public void Bind_Should_ReturnBindResult_When_ResultIsSuccess() + { + const string value = "value"; + var result = Result.Success(value); + + var boundResult = result.Bind(item => + { + return item.Length > 0 + ? Result.Success() + : Result.Failure(Error.Validation("Validation failed")); + }); + + boundResult.IsSuccess.Should().BeTrue(); + } + + [Fact(DisplayName = "Bind(Result, Func) → returns failure without invoking bind when the source generic result is a failure")] + public void Bind_Should_ReturnFailureWithoutInvokingBind_When_ResultIsFailure() + { + var sourceError = Error.Validation("Validation failed"); + var result = Result.Failure(sourceError); + var wasInvoked = false; + + var boundResult = result.Bind(_ => + { + wasInvoked = true; + return Result.Success(); + }); + + wasInvoked.Should().BeFalse(); + boundResult.IsFailure.Should().BeTrue(); + boundResult.Errors.Should().ContainSingle().Which.Should().BeSameAs(sourceError); + } + + [Fact(DisplayName = "Bind(Result, Func>) → throws ArgumentNullException when result is null")] + public void Bind_Should_ThrowArgumentNullException_When_GenericResultIsNull() + { + Action act = () => ResultExtensions.Bind(null!, value => Result.Success(value.Length)); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Bind(Result, Func>) → throws ArgumentNullException when bind is null")] + public void Bind_Should_ThrowArgumentNullException_When_GenericBindIsNull() + { + var result = Result.Success("value"); + Action act = () => result.Bind((Func>)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("bind"); + } + + [Fact(DisplayName = "Bind(Result, Func>) → returns the bind result when the source generic result is successful")] + public void Bind_Should_ReturnBindResult_When_GenericResultIsSuccess() + { + const string value = "value"; + var result = Result.Success(value); + + var boundResult = result.Bind(item => Result.Success(item.Length)); + + boundResult.IsSuccess.Should().BeTrue(); + boundResult.Value.Should().Be(value.Length); + } + + [Fact(DisplayName = "Bind(Result, Func>) → returns failure without invoking bind when the source generic result is a failure")] + public void Bind_Should_ReturnFailureWithoutInvokingBind_When_GenericResultIsFailure() + { + var sourceError = Error.Validation("Validation failed"); + var result = Result.Failure(sourceError); + var wasInvoked = false; + + var boundResult = result.Bind(value => + { + wasInvoked = true; + return Result.Success(value.Length); + }); + + wasInvoked.Should().BeFalse(); + boundResult.IsFailure.Should().BeTrue(); + boundResult.Errors.Should().ContainSingle().Which.Should().BeSameAs(sourceError); + } + + [Fact(DisplayName = "Bind(Result, Func>) → throws ArgumentNullException when result is null")] + public void Bind_Should_ThrowArgumentNullException_When_NonGenericResultIsNull() + { + Action act = () => ResultExtensions.Bind(null!, () => Result.Success(42)); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Bind(Result, Func>) → throws ArgumentNullException when bind is null")] + public void Bind_Should_ThrowArgumentNullException_When_NonGenericBindIsNull() + { + var result = Result.Success(); + Action act = () => result.Bind((Func>)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("bind"); + } + + [Fact(DisplayName = "Bind(Result, Func>) → returns the bind result when the source result is successful")] + public void Bind_Should_ReturnBindResult_When_NonGenericResultIsSuccess() + { + const int expectedValue = 42; + var result = Result.Success(); + + var boundResult = result.Bind(() => Result.Success(expectedValue)); + + boundResult.IsSuccess.Should().BeTrue(); + boundResult.Value.Should().Be(expectedValue); + } + + [Fact(DisplayName = "Bind(Result, Func>) → returns failure without invoking bind when the source result is a failure")] + public void Bind_Should_ReturnFailureWithoutInvokingBind_When_NonGenericResultIsFailure() + { + var sourceError = Error.Validation("Validation failed"); + var result = Result.Failure(sourceError); + var wasInvoked = false; + + var boundResult = result.Bind(() => + { + wasInvoked = true; + return Result.Success(42); + }); + + wasInvoked.Should().BeFalse(); + boundResult.IsFailure.Should().BeTrue(); + boundResult.Errors.Should().ContainSingle().Which.Should().BeSameAs(sourceError); + } + + [Fact(DisplayName = "BindAsync(Result, Func>>) → throws ArgumentNullException when result is null")] + public async Task BindAsync_Should_ThrowArgumentNullException_When_ResultIsNull() + { + Func act = async () => _ = await ResultExtensions.BindAsync( + null!, + value => Task.FromResult(Result.Success(value.Length))); + + var exception = (await act.Should().ThrowAsync()).Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "BindAsync(Result, Func>>) → throws ArgumentNullException when bind is null")] + public async Task BindAsync_Should_ThrowArgumentNullException_When_BindIsNull() + { + var result = Result.Success("value"); + Func act = async () => _ = await result.BindAsync((Func>>)null!); + + var exception = (await act.Should().ThrowAsync()).Which; + + exception.ParamName.Should().Be("bind"); + } + + [Fact(DisplayName = "BindAsync(Result, Func>>) → returns the bind result when the source generic result is successful")] + public async Task BindAsync_Should_ReturnBindResult_When_ResultIsSuccess() + { + const string value = "value"; + var result = Result.Success(value); + + var boundResult = await result.BindAsync(item => Task.FromResult(Result.Success(item.Length))); + + boundResult.IsSuccess.Should().BeTrue(); + boundResult.Value.Should().Be(value.Length); + } + + [Fact(DisplayName = "BindAsync(Result, Func>>) → returns failure without invoking bind when the source generic result is a failure")] + public async Task BindAsync_Should_ReturnFailureWithoutInvokingBind_When_ResultIsFailure() + { + var sourceError = Error.Validation("Validation failed"); + var result = Result.Failure(sourceError); + var wasInvoked = false; + + var boundResult = await result.BindAsync(value => + { + wasInvoked = true; + return Task.FromResult(Result.Success(value.Length)); + }); + + wasInvoked.Should().BeFalse(); + boundResult.IsFailure.Should().BeTrue(); + boundResult.Errors.Should().ContainSingle().Which.Should().BeSameAs(sourceError); + } + + [Fact(DisplayName = "BindAsync(Result, Func>>) → throws ArgumentNullException when result is null")] + public async Task BindAsync_Should_ThrowArgumentNullException_When_NonGenericResultIsNull() + { + Func act = async () => _ = await ResultExtensions.BindAsync( + null!, + () => Task.FromResult(Result.Success(42))); + + var exception = (await act.Should().ThrowAsync()).Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "BindAsync(Result, Func>>) → throws ArgumentNullException when bind is null")] + public async Task BindAsync_Should_ThrowArgumentNullException_When_NonGenericBindIsNull() + { + var result = Result.Success(); + Func act = async () => _ = await result.BindAsync((Func>>)null!); + + var exception = (await act.Should().ThrowAsync()).Which; + + exception.ParamName.Should().Be("bind"); + } + + [Fact(DisplayName = "BindAsync(Result, Func>>) → returns the bind result when the source result is successful")] + public async Task BindAsync_Should_ReturnBindResult_When_NonGenericResultIsSuccess() + { + const int expectedValue = 42; + var result = Result.Success(); + + var boundResult = await result.BindAsync(() => Task.FromResult(Result.Success(expectedValue))); + + boundResult.IsSuccess.Should().BeTrue(); + boundResult.Value.Should().Be(expectedValue); + } + + [Fact(DisplayName = "BindAsync(Result, Func>>) → returns failure without invoking bind when the source result is a failure")] + public async Task BindAsync_Should_ReturnFailureWithoutInvokingBind_When_NonGenericResultIsFailure() + { + var sourceError = Error.Validation("Validation failed"); + var result = Result.Failure(sourceError); + var wasInvoked = false; + + var boundResult = await result.BindAsync(() => + { + wasInvoked = true; + return Task.FromResult(Result.Success(42)); + }); + + wasInvoked.Should().BeFalse(); + boundResult.IsFailure.Should().BeTrue(); + boundResult.Errors.Should().ContainSingle().Which.Should().BeSameAs(sourceError); + } + + [Fact(DisplayName = "Ensure → throws ArgumentNullException when result is null")] + public void Ensure_Should_ThrowArgumentNullException_When_ResultIsNull() + { + Action act = () => ResultExtensions.Ensure( + null!, + _ => true, + Error.Validation("Validation failed")); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Ensure → throws ArgumentNullException when predicate is null")] + public void Ensure_Should_ThrowArgumentNullException_When_PredicateIsNull() + { + var result = Result.Success("value"); + Action act = () => result.Ensure(null!, Error.Validation("Validation failed")); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("predicate"); + } + + [Fact(DisplayName = "Ensure → throws ArgumentNullException when error is null")] + public void Ensure_Should_ThrowArgumentNullException_When_ErrorIsNull() + { + var result = Result.Success("value"); + Action act = () => result.Ensure(_ => true, null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("error"); + } + + [Fact(DisplayName = "Ensure → returns the original result when the source result is already a failure")] + public void Ensure_Should_ReturnOriginalResult_When_ResultIsFailure() + { + var result = Result.Failure(Error.Validation("Validation failed")); + var wasInvoked = false; + + var ensuredResult = result.Ensure( + _ => + { + wasInvoked = true; + return true; + }, + Error.Conflict("Conflict")); + + wasInvoked.Should().BeFalse(); + ensuredResult.Should().BeSameAs(result); + } + + [Fact(DisplayName = "Ensure → returns the original result when predicate returns true")] + public void Ensure_Should_ReturnOriginalResult_When_PredicateReturnsTrue() + { + const string value = "value"; + var result = Result.Success(value); + + var ensuredResult = result.Ensure( + item => item.Length == value.Length, + Error.Validation("Validation failed")); + + ensuredResult.Should().BeSameAs(result); + } + + [Fact(DisplayName = "Ensure → returns failure when predicate returns false")] + public void Ensure_Should_ReturnFailure_When_PredicateReturnsFalse() + { + var error = Error.Validation("Validation failed"); + const string value = "value"; + const int invalidLength = 10; + var result = Result.Success(value); + + var ensuredResult = result.Ensure(item => item.Length == invalidLength, error); + + ensuredResult.IsFailure.Should().BeTrue(); + ensuredResult.Errors.Should().ContainSingle().Which.Should().BeSameAs(error); + } + + [Fact(DisplayName = "Tap → throws ArgumentNullException when result is null")] + public void Tap_Should_ThrowArgumentNullException_When_ResultIsNull() + { + Action act = () => ResultExtensions.Tap(null!, _ => { }); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Tap → throws ArgumentNullException when action is null")] + public void Tap_Should_ThrowArgumentNullException_When_ActionIsNull() + { + var result = Result.Success("value"); + Action act = () => result.Tap(null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("action"); + } + + [Fact(DisplayName = "Tap → executes action and returns the original result when the result is successful")] + public void Tap_Should_InvokeActionAndReturnOriginalResult_When_ResultIsSuccess() + { + const string value = "value"; + var result = Result.Success(value); + string? tappedValue = null; + + var tappedResult = result.Tap(item => tappedValue = item); + + tappedValue.Should().Be(value); + tappedResult.Should().BeSameAs(result); + } + + [Fact(DisplayName = "Tap → returns the original result without invoking action when the result is a failure")] + public void Tap_Should_ReturnOriginalResultWithoutInvokingAction_When_ResultIsFailure() + { + var result = Result.Failure(Error.Validation("Validation failed")); + var wasInvoked = false; + + var tappedResult = result.Tap(_ => wasInvoked = true); + + wasInvoked.Should().BeFalse(); + tappedResult.Should().BeSameAs(result); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → throws ArgumentNullException when result is null")] + public void Match_Should_ThrowArgumentNullException_When_ResultIsNull() + { + Action act = () => ResultExtensions.Match(null!, () => 42, _ => 0); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → throws ArgumentNullException when onSuccess is null")] + public void Match_Should_ThrowArgumentNullException_When_OnSuccessIsNull() + { + var result = Result.Success(); + Action act = () => result.Match((Func)null!, _ => 0); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("onSuccess"); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → throws ArgumentNullException when onFailure is null")] + public void Match_Should_ThrowArgumentNullException_When_OnFailureIsNull() + { + var result = Result.Success(); + Action act = () => result.Match(() => 42, null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("onFailure"); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → invokes onSuccess when the result is successful")] + public void Match_Should_InvokeOnSuccess_When_ResultIsSuccess() + { + const int expectedValue = 42; + var result = Result.Success(); + var onFailureInvoked = false; + + var matchResult = result.Match( + () => expectedValue, + _ => + { + onFailureInvoked = true; + return 0; + }); + + matchResult.Should().Be(expectedValue); + onFailureInvoked.Should().BeFalse(); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → invokes onFailure with errors when the result is a failure")] + public void Match_Should_InvokeOnFailureWithErrors_When_ResultIsFailure() + { + var error = Error.Validation("Validation failed"); + var result = Result.Failure(error); + var onSuccessInvoked = false; + + var matchResult = result.Match( + () => + { + onSuccessInvoked = true; + return 42; + }, + errors => + { + errors.Should().ContainSingle().Which.Should().BeSameAs(error); + return 0; + }); + + matchResult.Should().Be(0); + onSuccessInvoked.Should().BeFalse(); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → throws ArgumentNullException when result is null")] + public void Match_Should_ThrowArgumentNullException_When_GenericResultIsNull() + { + Action act = () => ResultExtensions.Match(null!, _ => 42, _ => 0); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("result"); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → throws ArgumentNullException when onSuccess is null")] + public void Match_Should_ThrowArgumentNullException_When_GenericOnSuccessIsNull() + { + var result = Result.Success("value"); + Action act = () => result.Match((Func)null!, _ => 0); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("onSuccess"); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → throws ArgumentNullException when onFailure is null")] + public void Match_Should_ThrowArgumentNullException_When_GenericOnFailureIsNull() + { + var result = Result.Success("value"); + Action act = () => result.Match(_ => 42, null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("onFailure"); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → invokes onSuccess with the value when the result is successful")] + public void Match_Should_InvokeOnSuccessWithValue_When_GenericResultIsSuccess() + { + const string value = "value"; + var result = Result.Success(value); + var onFailureInvoked = false; + + var matchResult = result.Match( + item => item.Length, + _ => + { + onFailureInvoked = true; + return 0; + }); + + matchResult.Should().Be(value.Length); + onFailureInvoked.Should().BeFalse(); + } + + [Fact(DisplayName = "Match(Result, Func, Func, TOut>) → invokes onFailure with errors when the result is a failure")] + public void Match_Should_InvokeOnFailureWithErrors_When_GenericResultIsFailure() + { + var error = Error.Validation("Validation failed"); + var result = Result.Failure(error); + var onSuccessInvoked = false; + + var matchResult = result.Match( + _ => + { + onSuccessInvoked = true; + return 42; + }, + errors => + { + errors.Should().ContainSingle().Which.Should().BeSameAs(error); + return 0; + }); + + matchResult.Should().Be(0); + onSuccessInvoked.Should().BeFalse(); + } +} diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultTests.cs b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultTests.cs new file mode 100644 index 0000000..66e1f67 --- /dev/null +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultTests.cs @@ -0,0 +1,215 @@ +using System.Reflection; + +namespace PANiXiDA.Core.ResultPattern.UnitTests; + +public sealed class ResultTests +{ + [Fact(DisplayName = "Success() → returns a successful result when called without errors")] + public void Success_Should_ReturnSuccessfulResult_When_Called() + { + var result = Result.Success(); + + result.IsSuccess.Should().BeTrue(); + result.IsFailure.Should().BeFalse(); + result.Errors.Should().BeEmpty(); + } + + [Fact(DisplayName = "FirstError → throws InvalidOperationException when the result is successful")] + public void FirstError_Should_ThrowInvalidOperationException_When_ResultIsSuccess() + { + var result = Result.Success(); + Action act = () => _ = result.FirstError; + + var exception = act.Should().Throw().Which; + + exception.Message.Should().Be("Successful result does not contain errors."); + } + + [Fact(DisplayName = "FirstError → returns the first error when the result is a failure")] + public void FirstError_Should_ReturnFirstError_When_ResultIsFailure() + { + var firstError = Error.Validation("Validation failed"); + var secondError = Error.Conflict("Conflict"); + var result = Result.Failure([firstError, secondError]); + + var firstResultError = result.FirstError; + + firstResultError.Should().BeSameAs(firstError); + } + + [Fact(DisplayName = "Failure(Error) → returns a failed result when an error is provided")] + public void Failure_Should_ReturnFailureResult_When_ErrorIsProvided() + { + var error = Error.Validation("Validation failed"); + + var result = Result.Failure(error); + + result.IsSuccess.Should().BeFalse(); + result.IsFailure.Should().BeTrue(); + result.Errors.Should().ContainSingle().Which.Should().BeSameAs(error); + } + + [Fact(DisplayName = "Failure(Error) → throws ArgumentNullException when error is null")] + public void Failure_Should_ThrowArgumentNullException_When_ErrorIsNull() + { + Action act = () => Result.Failure((Error)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("error"); + } + + [Fact(DisplayName = "Failure(IEnumerable) → returns a failed result when the collection contains errors")] + public void Failure_Should_ReturnFailureResult_When_ErrorCollectionContainsErrors() + { + var firstError = Error.Validation("Validation failed"); + var secondError = Error.Conflict("Conflict"); + + var result = Result.Failure([firstError, secondError]); + + result.IsFailure.Should().BeTrue(); + result.Errors.Should().Equal(firstError, secondError); + } + + [Fact(DisplayName = "Failure(IEnumerable) → filters out null values when the collection contains null")] + public void Failure_Should_FilterOutNullErrors_When_ErrorCollectionContainsNullValues() + { + var error = Error.Validation("Validation failed"); + + var result = Result.Failure([error, null!]); + + result.Errors.Should().ContainSingle().Which.Should().BeSameAs(error); + } + + [Fact(DisplayName = "Failure(IEnumerable) → preserves error order when the collection contains multiple errors")] + public void Failure_Should_PreserveErrorOrder_When_ErrorCollectionContainsMultipleErrors() + { + var firstError = Error.Validation("Validation failed"); + var secondError = Error.NotFound("Not found"); + var thirdError = Error.Conflict("Conflict"); + + var result = Result.Failure([firstError, secondError, thirdError]); + + result.Errors.Should().Equal(firstError, secondError, thirdError); + } + + [Fact(DisplayName = "Failure(IEnumerable) → throws ArgumentNullException when the error collection is null")] + public void Failure_Should_ThrowArgumentNullException_When_ErrorCollectionIsNull() + { + Action act = () => Result.Failure((IEnumerable)null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("errors"); + } + + [Fact(DisplayName = "Failure(IEnumerable) → throws ArgumentException when the error collection is empty")] + public void Failure_Should_ThrowArgumentException_When_ErrorCollectionIsEmpty() + { + Action act = () => Result.Failure([]); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("errors"); + } + + [Fact(DisplayName = "Failure(IEnumerable) → throws ArgumentException when the collection contains only null")] + public void Failure_Should_ThrowArgumentException_When_ErrorCollectionContainsOnlyNullValues() + { + Action act = () => Result.Failure([null!]); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("errors"); + } + + [Fact(DisplayName = "Combine → throws ArgumentNullException when the results array is null")] + public void Combine_Should_ThrowArgumentNullException_When_ResultsArrayIsNull() + { + Action act = () => Result.Combine(null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("results"); + } + + [Fact(DisplayName = "Combine → returns a successful result when the results array is empty")] + public void Combine_Should_ReturnSuccessfulResult_When_ResultsArrayIsEmpty() + { + var result = Result.Combine(); + + result.IsSuccess.Should().BeTrue(); + result.Errors.Should().BeEmpty(); + } + + [Fact(DisplayName = "Combine → returns a successful result when all results are successful")] + public void Combine_Should_ReturnSuccessfulResult_When_AllResultsAreSuccessful() + { + var first = Result.Success(); + var second = Result.Success(); + + var result = Result.Combine(first, second); + + result.IsSuccess.Should().BeTrue(); + result.Errors.Should().BeEmpty(); + } + + [Fact(DisplayName = "Combine → returns a failure with aggregated errors when the results contain errors")] + public void Combine_Should_ReturnFailureWithAggregatedErrors_When_AnyResultIsFailure() + { + var firstError = Error.Validation("Validation failed"); + var secondError = Error.NotFound("Not found"); + + var first = Result.Success(); + var second = Result.Failure(firstError); + var third = Result.Failure([secondError]); + + var result = Result.Combine(first, second, third); + + result.IsFailure.Should().BeTrue(); + result.Errors.Should().Equal(firstError, secondError); + } + + [Fact(DisplayName = "Result ctor → throws ArgumentException when a successful result contains errors")] + public void Constructor_Should_ThrowArgumentException_When_SuccessResultContainsErrors() + { + var errors = new[] + { + Error.Validation("Validation failed") + }; + + Action act = () => _ = CreateResult(true, errors); + + var exception = act.Should().Throw() + .Which.InnerException.Should().BeOfType() + .Subject; + + exception.ParamName.Should().Be("errors"); + } + + [Fact(DisplayName = "Result ctor → throws ArgumentException when a failed result does not contain errors")] + public void Constructor_Should_ThrowArgumentException_When_FailureResultDoesNotContainErrors() + { + var errors = Array.Empty(); + Action act = () => _ = CreateResult(false, errors); + + var exception = act.Should().Throw() + .Which.InnerException.Should().BeOfType() + .Subject; + + exception.ParamName.Should().Be("errors"); + } + + private static Result CreateResult(bool isSuccess, Error[] errors) + { + var constructor = typeof(Result).GetConstructor( + BindingFlags.Instance | BindingFlags.NonPublic, + binder: null, + [typeof(bool), typeof(Error[])], + modifiers: null); + + constructor.Should().NotBeNull(); + + return (Result)constructor.Invoke([isSuccess, errors]); + } +} diff --git a/version.json b/version.json new file mode 100644 index 0000000..37dd5bf --- /dev/null +++ b/version.json @@ -0,0 +1,22 @@ +{ + "$schema": "https://raw.githubusercontent.com/dotnet/Nerdbank.GitVersioning/main/src/NerdBank.GitVersioning/version.schema.json", + "version": "1.0", + "publicReleaseRefSpec": [ + "^refs/heads/main$", + "^refs/heads/master$" + ], + "cloudBuild": { + "buildNumber": { + "enabled": true + } + }, + "pathFilters": [ + ":/src/PANiXiDA.Core.ResultPattern/", + ":/Directory.Build.props", + ":/Directory.Packages.props", + ":/global.json", + ":/version.json", + ":/README.md", + ":/icon.png" + ] +} From 89cbe91750b7c4b79e57890193d85b43c9d1d71c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 17:29:58 +0400 Subject: [PATCH 02/11] =?UTF-8?q?=D0=BF=D0=BE=D0=BC=D0=B5=D0=BD=D1=8F?= =?UTF-8?q?=D0=BB=20=D0=B2=20=D1=81=D1=81=D1=8B=D0=BB=D0=BA=D1=83=20=D0=BD?= =?UTF-8?q?=D0=B0=20=D1=80=D0=B5=D0=BF=D0=BE=D0=B7=D0=B8=D1=82=D0=BE=D1=80?= =?UTF-8?q?=D0=B8=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../PANiXiDA.Core.ResultPattern.csproj | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/PANiXiDA.Core.ResultPattern/PANiXiDA.Core.ResultPattern.csproj b/src/PANiXiDA.Core.ResultPattern/PANiXiDA.Core.ResultPattern.csproj index 3ce6aec..447089f 100644 --- a/src/PANiXiDA.Core.ResultPattern/PANiXiDA.Core.ResultPattern.csproj +++ b/src/PANiXiDA.Core.ResultPattern/PANiXiDA.Core.ResultPattern.csproj @@ -8,8 +8,8 @@ A library for implementing the Result pattern in .NET applications with typed errors, result composition support, and convenient error handling without exceptions in business logic. Result;ResultPattern;Errors;Functional;DotNet - https://github.com/PANiXiDA-Dotnet-Core/panixida-core-result-pattern - https://github.com/PANiXiDA-Dotnet-Core/panixida-core-result-pattern + https://github.com/PANiXiDA-Dotnet-Core/result-pattern + https://github.com/PANiXiDA-Dotnet-Core/result-pattern From f137b7044711d3208a6dfd95ab75a8a4feb137df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 17:41:34 +0400 Subject: [PATCH 03/11] =?UTF-8?q?=D0=BF=D0=BE=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D0=BB=20ci?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/ci.yml | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d136fef..1901486 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -12,12 +12,15 @@ permissions: jobs: format: uses: PANiXiDA-Infrastructure/ci-cd/.github/workflows/dotnet-format.yml@main + secrets: + registry-user: ${{ secrets.REGISTRY_USER }} + registry-token: ${{ secrets.REGISTRY_TOKEN }} tests: uses: PANiXiDA-Infrastructure/ci-cd/.github/workflows/dotnet-tests.yml@main - with: - coverage_assembly_filters: "+PANiXiDA.Core*;-*Tests*" - coverage_threshold: "100" + secrets: + registry-user: ${{ secrets.REGISTRY_USER }} + registry-token: ${{ secrets.REGISTRY_TOKEN }} publish: if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }} From 9a9110b73ebef69657891e2af2e40734e1c9bb6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 18:00:45 +0400 Subject: [PATCH 04/11] =?UTF-8?q?=D0=BF=D0=BE=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D0=BB=20README.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 0a7bf87..f423af6 100644 --- a/README.md +++ b/README.md @@ -643,7 +643,7 @@ See the [LICENSE](LICENSE) file for details. ## Maintainers / Contacts -Maintained by the PANiXiDA / Space App team. +Maintained by the PANiXiDA. Repository: From bb908354fec65b8cc579018adc83269c869f5790 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 18:04:33 +0400 Subject: [PATCH 05/11] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20$(NoWarn);NU1507?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Directory.Build.props | 1 + 1 file changed, 1 insertion(+) diff --git a/Directory.Build.props b/Directory.Build.props index 60634c9..55f9349 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -11,6 +11,7 @@ true true latest + $(NoWarn);NU1507 From 3ab7469cb78f784f983c2ca0eb69002c6c9fe7a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 18:15:58 +0400 Subject: [PATCH 06/11] =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index f423af6..9801e31 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,7 @@ It is designed for .NET developers who want predictable result-based workflows, ## Status + [![Build](https://img.shields.io/badge/build-passing-brightgreen)](#development) [![Tests](https://img.shields.io/badge/tests-passing-brightgreen)](#development) [![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](#development) From 6eb47cd0dda31b805b5b72793132f90b408d72be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 19:11:18 +0400 Subject: [PATCH 07/11] =?UTF-8?q?=D0=BF=D0=B5=D1=80=D0=B5=D0=BF=D0=B8?= =?UTF-8?q?=D1=81=D0=B0=D0=BB=20=D0=BD=D0=B5=D0=BA=D0=BE=D1=82=D0=BE=D1=80?= =?UTF-8?q?=D1=8B=D0=B5=20=D0=BA=D0=BE=D0=BD=D1=84=D0=B8=D0=B3=20=D1=84?= =?UTF-8?q?=D0=B0=D0=B9=D0=BB=D1=8B=20=D0=BF=D0=BE=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D0=BB=20readme=20=D1=81=D1=82=D0=B0=D1=82=D1=83=D1=81?= =?UTF-8?q?=D1=8B=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=B4=D0=BE=D0=B1?= =?UTF-8?q?=D0=B0=D0=B2=D0=B8=D0=BB=20=D0=B4=D0=BE=20100%=20=D0=BF=D0=BE?= =?UTF-8?q?=D0=BA=D1=80=D1=8B=D1=82=D0=B8=D1=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .editorconfig | 3 ++ .gitattributes | 1 + Directory.Build.props | 28 ------------------ Directory.Build.targets | 29 +++++++++++++++++++ PANiXiDA.Core.ResultPattern.slnx | 1 + README.md | 15 ++++------ .../ErrorTests.cs | 12 ++++++++ 7 files changed, 52 insertions(+), 37 deletions(-) create mode 100644 Directory.Build.targets diff --git a/.editorconfig b/.editorconfig index 8ed5105..9e451e5 100644 --- a/.editorconfig +++ b/.editorconfig @@ -136,3 +136,6 @@ dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:sil dotnet_style_readonly_field = true:suggestion dotnet_diagnostic.IDE0005.severity = error dotnet_diagnostic.CS1591.severity = none + +[src/**/*.cs] +dotnet_diagnostic.CS1591.severity = error diff --git a/.gitattributes b/.gitattributes index 97a0d68..20a51ba 100644 --- a/.gitattributes +++ b/.gitattributes @@ -9,6 +9,7 @@ *.props text eol=lf *.targets text eol=lf *.sln text eol=crlf +*.slnx text eol=lf # Config / docs *.json text eol=lf diff --git a/Directory.Build.props b/Directory.Build.props index 55f9349..97d7c62 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -13,32 +13,4 @@ latest $(NoWarn);NU1507 - - - Space App - Space App - git - - true - true - - true - snupkg - - README.md - Apache-2.0 - icon.png - - - - - - - diff --git a/Directory.Build.targets b/Directory.Build.targets new file mode 100644 index 0000000..f6b4be9 --- /dev/null +++ b/Directory.Build.targets @@ -0,0 +1,29 @@ + + + PANiXiDA + PANiXiDA + git + + true + true + + true + snupkg + + README.md + Apache-2.0 + icon.png + + + + + + + + diff --git a/PANiXiDA.Core.ResultPattern.slnx b/PANiXiDA.Core.ResultPattern.slnx index 1add422..7934d64 100644 --- a/PANiXiDA.Core.ResultPattern.slnx +++ b/PANiXiDA.Core.ResultPattern.slnx @@ -7,6 +7,7 @@ + diff --git a/README.md b/README.md index 9801e31..9a572dd 100644 --- a/README.md +++ b/README.md @@ -6,12 +6,10 @@ It is designed for .NET developers who want predictable result-based workflows, ## Status - -[![Build](https://img.shields.io/badge/build-passing-brightgreen)](#development) -[![Tests](https://img.shields.io/badge/tests-passing-brightgreen)](#development) -[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](#development) -[![NuGet](https://img.shields.io/badge/NuGet-PANiXiDA.Core.ResultPattern-blue)](#installation) -[![License](https://img.shields.io/badge/license-Apache%202.0-blue)](#license) +[![CI](https://github.com/PANiXiDA-Dotnet-Core/result-pattern/actions/workflows/ci.yml/badge.svg)](https://github.com/PANiXiDA-Dotnet-Core/result-pattern/actions/workflows/ci.yml) +[![NuGet](https://img.shields.io/nuget/v/PANiXiDA.Core.ResultPattern.svg)](https://www.nuget.org/packages/PANiXiDA.Core.ResultPattern) +[![NuGet downloads](https://img.shields.io/nuget/dt/PANiXiDA.Core.ResultPattern.svg)](https://www.nuget.org/packages/PANiXiDA.Core.ResultPattern) +[![License](https://img.shields.io/github/license/PANiXiDA-Dotnet-Core/result-pattern.svg)](LICENSE) ## Overview @@ -62,7 +60,7 @@ The library targets `net10.0`. -```` +``` ### Minimal import @@ -594,7 +592,6 @@ Potential future improvements: * add more advanced composition helpers if a clear use case appears; * extend documentation with more domain-oriented examples; * add dedicated examples for ASP.NET Core minimal APIs; -* add package badges with exact CI and NuGet URLs; * keep the package as a reusable standard for future PANiXiDA NuGet libraries. ## Contributing @@ -648,7 +645,7 @@ Maintained by the PANiXiDA. Repository: -* `PANiXiDA-Dotnet-Core/panixida-core-result-pattern` +* `PANiXiDA-Dotnet-Core/result-pattern` For questions or improvements, use: diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs index e061fe0..142d42c 100644 --- a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs @@ -32,6 +32,18 @@ public void Constructor_Should_InitializeEmptyMetadata_When_MetadataIsNull() error.Metadata.Should().BeEmpty(); } + [Fact(DisplayName = "Error copy → returns an equivalent new error when copied with record syntax")] + public void Copy_Should_ReturnEquivalentNewError_When_RecordWithExpressionIsUsed() + { + var error = Error.Validation("Validation failed") + .WithField("email"); + + var copiedError = error with { }; + + copiedError.Should().NotBeSameAs(error); + copiedError.Should().Be(error); + } + [Fact(DisplayName = "Error ctor → throws ArgumentException when message is null")] public void Constructor_Should_ThrowArgumentException_When_MessageIsNull() { From 55156b6fb9f21702fa4cbe83c56f63be3e14741e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 19:21:20 +0400 Subject: [PATCH 08/11] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D1=82=D0=B0=D1=80=D0=B3=D0=B5=D1=82=20=D1=84=D1=80?= =?UTF-8?q?=D0=B5=D0=B9=D0=BC=D0=B2=D0=BE=D1=80=D0=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9a572dd..803cdf9 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,7 @@ It is designed for .NET developers who want predictable result-based workflows, [![CI](https://github.com/PANiXiDA-Dotnet-Core/result-pattern/actions/workflows/ci.yml/badge.svg)](https://github.com/PANiXiDA-Dotnet-Core/result-pattern/actions/workflows/ci.yml) [![NuGet](https://img.shields.io/nuget/v/PANiXiDA.Core.ResultPattern.svg)](https://www.nuget.org/packages/PANiXiDA.Core.ResultPattern) [![NuGet downloads](https://img.shields.io/nuget/dt/PANiXiDA.Core.ResultPattern.svg)](https://www.nuget.org/packages/PANiXiDA.Core.ResultPattern) +[![Target Framework](https://img.shields.io/badge/target-net10.0-512BD4)](https://dotnet.microsoft.com/) [![License](https://img.shields.io/github/license/PANiXiDA-Dotnet-Core/result-pattern.svg)](LICENSE) ## Overview From 6b70d9309453abfa994c8e76ab789a3e2d7f73dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 19:30:16 +0400 Subject: [PATCH 09/11] =?UTF-8?q?=D0=BE=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20agents.md=20=D0=B4=D0=BB=D1=8F=20=D0=BD=D0=BE=D0=B2?= =?UTF-8?q?=D0=BE=D0=B3=D0=BE=20readme=20=D0=B8=20=D0=B4=D0=BE=D0=B1=D0=B0?= =?UTF-8?q?=D0=B2=D0=B8=D0=BB=20Directory.Build.targets=20=D0=B2=20version?= =?UTF-8?q?.json?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- AGENTS.md | 9 ++++++--- version.json | 1 + 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 92ff87b..722d98f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -56,9 +56,12 @@ The goal is to keep package structure, CI, versioning, tests, documentation, and ## Documentation -- Update `README.md` when public behavior changes. -- Keep installation, target framework, and examples accurate. -- Keep examples compilable and aligned with the current API. +- Update `README.md` when public behavior, public API, package metadata, or development workflow changes. +- Keep the README structure aligned with the repository standard. +- Keep installation instructions, target framework, badges, and package information accurate. +- Keep all examples compilable and aligned with the current API. +- Ensure usage examples reflect real and recommended library usage. +- Remove outdated or duplicate documentation when updating existing sections. ## Build and validation diff --git a/version.json b/version.json index 37dd5bf..427b1ae 100644 --- a/version.json +++ b/version.json @@ -13,6 +13,7 @@ "pathFilters": [ ":/src/PANiXiDA.Core.ResultPattern/", ":/Directory.Build.props", + ":/Directory.Build.targets", ":/Directory.Packages.props", ":/global.json", ":/version.json", From 7889027adc9559cae7817ace3ff07a4681f182a1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 19:58:36 +0400 Subject: [PATCH 10/11] =?UTF-8?q?=D0=BF=D0=BE=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D0=BB=20=D0=BE=D1=81=D0=BD=D0=BE=D0=B2=D0=BD=D0=BE=D0=B9?= =?UTF-8?q?=20=D0=BF=D0=B0=D0=BA=D0=B5=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 + src/PANiXiDA.Core.ResultPattern/Error.cs | 9 +++- src/PANiXiDA.Core.ResultPattern/Result.cs | 13 ++++- .../ErrorTests.cs | 36 ++++++++++++- .../ResultTests.cs | 52 +++++++++++++++++++ 5 files changed, 107 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 803cdf9..23a6920 100644 --- a/README.md +++ b/README.md @@ -459,6 +459,7 @@ The only consumer-side requirement is referencing the package from a compatible ├── .gitattributes ├── .gitignore ├── Directory.Build.props +├── Directory.Build.targets ├── Directory.Packages.props ├── global.json ├── version.json @@ -471,6 +472,7 @@ The only consumer-side requirement is referencing the package from a compatible * `src/` — library source code * `tests/` — automated tests * `Directory.Build.props` — shared MSBuild settings +* `Directory.Build.targets` — shared package metadata and package content settings * `Directory.Packages.props` — centralized package versions * `global.json` — SDK and test runner configuration * `version.json` — Nerdbank.GitVersioning configuration diff --git a/src/PANiXiDA.Core.ResultPattern/Error.cs b/src/PANiXiDA.Core.ResultPattern/Error.cs index 4120716..275c55d 100644 --- a/src/PANiXiDA.Core.ResultPattern/Error.cs +++ b/src/PANiXiDA.Core.ResultPattern/Error.cs @@ -1,4 +1,6 @@ -namespace PANiXiDA.Core.ResultPattern; +using System.Collections.ObjectModel; + +namespace PANiXiDA.Core.ResultPattern; /// /// Represents an immutable error returned by an operation result. @@ -28,7 +30,10 @@ public Error( Message = message; Type = type; - Metadata = metadata ?? new Dictionary(); + Metadata = new ReadOnlyDictionary( + metadata is null + ? [] + : new Dictionary(metadata)); } /// diff --git a/src/PANiXiDA.Core.ResultPattern/Result.cs b/src/PANiXiDA.Core.ResultPattern/Result.cs index 707e136..202bee7 100644 --- a/src/PANiXiDA.Core.ResultPattern/Result.cs +++ b/src/PANiXiDA.Core.ResultPattern/Result.cs @@ -1,4 +1,6 @@ -namespace PANiXiDA.Core.ResultPattern; +using System.Collections.ObjectModel; + +namespace PANiXiDA.Core.ResultPattern; /// /// Represents the result of an operation that can complete successfully or fail with an error. @@ -17,6 +19,8 @@ public class Result /// Errors associated with the result. protected Result(bool isSuccess, Error[] errors) { + ArgumentNullException.ThrowIfNull(errors); + if (isSuccess && errors.Length > 0) { throw new ArgumentException("Successful result cannot contain errors.", nameof(errors)); @@ -28,7 +32,7 @@ protected Result(bool isSuccess, Error[] errors) } IsSuccess = isSuccess; - Errors = errors; + Errors = new ReadOnlyCollection(errors.ToArray()); } /// @@ -162,6 +166,11 @@ public static Result Combine(params Result[] results) { ArgumentNullException.ThrowIfNull(results); + if (results.Any(static item => item is null)) + { + throw new ArgumentException("Results collection cannot contain null values.", nameof(results)); + } + var errors = results .Where(item => item.IsFailure) .SelectMany(item => item.Errors) diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs index 142d42c..40c7ffe 100644 --- a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ErrorTests.cs @@ -19,7 +19,41 @@ public void Constructor_Should_SetProperties_When_MessageTypeAndMetadataAreValid error.Type.Should().Be(ErrorType.Validation); error.Metadata.Should().ContainSingle() .Which.Should().Be(new KeyValuePair(metadataKey, metadataValue)); - error.Metadata.Should().BeSameAs(metadata); + error.Metadata.Should().NotBeSameAs(metadata); + } + + [Fact(DisplayName = "Error ctor → creates a defensive metadata copy when metadata is provided")] + public void Constructor_Should_CreateDefensiveMetadataCopy_When_MetadataIsProvided() + { + const string metadataKey = "code"; + const int originalMetadataValue = 42; + const int changedMetadataValue = 100; + var metadata = new Dictionary + { + [metadataKey] = originalMetadataValue + }; + + var error = new Error("Validation failed", ErrorType.Validation, metadata); + + metadata[metadataKey] = changedMetadataValue; + metadata["extra"] = true; + + error.Metadata.Should().ContainSingle() + .Which.Should().Be(new KeyValuePair(metadataKey, originalMetadataValue)); + } + + [Fact(DisplayName = "Error metadata → throws NotSupportedException when metadata is cast to a mutable dictionary and modified")] + public void Metadata_Should_ThrowNotSupportedException_When_CastToMutableDictionaryAndModified() + { + var error = Error.Validation("Validation failed") + .WithMetadata("code", 42); + var metadata = error.Metadata.Should() + .BeAssignableTo>() + .Subject; + + Action act = () => metadata["code"] = 100; + + act.Should().Throw(); } [Fact(DisplayName = "Error ctor → creates empty metadata when metadata is not provided")] diff --git a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultTests.cs b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultTests.cs index 66e1f67..ffaa98b 100644 --- a/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultTests.cs +++ b/tests/PANiXiDA.Core.ResultPattern.UnitTests/ResultTests.cs @@ -71,6 +71,36 @@ public void Failure_Should_ReturnFailureResult_When_ErrorCollectionContainsError result.Errors.Should().Equal(firstError, secondError); } + [Fact(DisplayName = "Result errors → creates a defensive error copy when constructed")] + public void Errors_Should_CreateDefensiveCopy_When_ResultIsConstructed() + { + var firstError = Error.Validation("Validation failed"); + var secondError = Error.Conflict("Conflict"); + var errors = new[] + { + firstError + }; + var result = CreateResult(false, errors); + + errors[0] = secondError; + + result.Errors.Should().ContainSingle().Which.Should().BeSameAs(firstError); + } + + [Fact(DisplayName = "Result errors → throws NotSupportedException when errors are cast to a mutable list and modified")] + public void Errors_Should_ThrowNotSupportedException_When_CastToMutableListAndModified() + { + var error = Error.Validation("Validation failed"); + var result = Result.Failure(error); + var errors = result.Errors.Should() + .BeAssignableTo>() + .Subject; + + Action act = () => errors[0] = Error.Conflict("Conflict"); + + act.Should().Throw(); + } + [Fact(DisplayName = "Failure(IEnumerable) → filters out null values when the collection contains null")] public void Failure_Should_FilterOutNullErrors_When_ErrorCollectionContainsNullValues() { @@ -133,6 +163,16 @@ public void Combine_Should_ThrowArgumentNullException_When_ResultsArrayIsNull() exception.ParamName.Should().Be("results"); } + [Fact(DisplayName = "Combine → throws ArgumentException when the results array contains null")] + public void Combine_Should_ThrowArgumentException_When_ResultsArrayContainsNull() + { + Action act = () => Result.Combine(Result.Success(), null!); + + var exception = act.Should().Throw().Which; + + exception.ParamName.Should().Be("results"); + } + [Fact(DisplayName = "Combine → returns a successful result when the results array is empty")] public void Combine_Should_ReturnSuccessfulResult_When_ResultsArrayIsEmpty() { @@ -187,6 +227,18 @@ public void Constructor_Should_ThrowArgumentException_When_SuccessResultContains exception.ParamName.Should().Be("errors"); } + [Fact(DisplayName = "Result ctor → throws ArgumentNullException when errors are null")] + public void Constructor_Should_ThrowArgumentNullException_When_ErrorsAreNull() + { + Action act = () => _ = CreateResult(true, null!); + + var exception = act.Should().Throw() + .Which.InnerException.Should().BeOfType() + .Subject; + + exception.ParamName.Should().Be("errors"); + } + [Fact(DisplayName = "Result ctor → throws ArgumentException when a failed result does not contain errors")] public void Constructor_Should_ThrowArgumentException_When_FailureResultDoesNotContainErrors() { From e6080064c5db3522ffcbbd0bb90dbfbbf1ada99b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D0=B8=D1=85=D0=B0=D0=B8=D0=BB?= Date: Sat, 18 Apr 2026 20:38:30 +0400 Subject: [PATCH 11/11] =?UTF-8?q?=D0=BF=D0=BE=D0=BC=D0=B5=D0=BD=D1=8F?= =?UTF-8?q?=D0=BB=20=D0=BF=D1=83=D0=B1=D0=BB=D0=B8=D0=BA=D0=B0=D1=86=D0=B8?= =?UTF-8?q?=D1=8E=20=D0=BD=D0=B0=20=D0=BF=D1=83=D0=B1=D0=BB=D0=B8=D1=87?= =?UTF-8?q?=D0=BD=D1=8B=D0=B9=20=D0=BD=D1=83=D0=B3=D0=B5=D1=82=20=D0=BF?= =?UTF-8?q?=D0=B0=D0=BA=D0=B5=D1=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/workflows/ci.yml | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1901486..620092a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -23,13 +23,12 @@ jobs: registry-token: ${{ secrets.REGISTRY_TOKEN }} publish: - if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }} - needs: - - format - - tests - uses: PANiXiDA-Infrastructure/ci-cd/.github/workflows/dotnet-publish-github-nuget.yml@main - secrets: - GH_PACKAGES_TOKEN: ${{ secrets.GITHUB_TOKEN }} + needs: + - format + - tests + uses: PANiXiDA-Infrastructure/ci-cd/.github/workflows/dotnet-publish-global-nuget.yml@main + secrets: + NUGET_API_KEY: ${{ secrets.NUGET_API_KEY }} notify: if: ${{ always() && github.event_name != 'pull_request' }}