pax_global_header 0000666 0000000 0000000 00000000064 14606620746 0014525 g ustar 00root root 0000000 0000000 52 comment=545252053730cc1323f849fffb1ad80f36f16f90
solid-result-2.0.0/ 0000775 0000000 0000000 00000000000 14606620746 0014152 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/.github/ 0000775 0000000 0000000 00000000000 14606620746 0015512 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/.github/workflows/ 0000775 0000000 0000000 00000000000 14606620746 0017547 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/.github/workflows/main.yml 0000664 0000000 0000000 00000002144 14606620746 0021217 0 ustar 00root root 0000000 0000000 name: Ruby
on:
push:
branches:
- main
pull_request:
jobs:
test:
runs-on: ubuntu-latest
name: Ruby ${{ matrix.ruby }}
strategy:
matrix:
ruby: [2.7, 3.0, 3.1, 3.2, 3.3, head]
env:
CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
steps:
- uses: actions/checkout@v4
- name: Set up Ruby
uses: ruby/setup-ruby@v1
with:
ruby-version: ${{ matrix.ruby }}
bundler-cache: true
- name: Run Solid::Result.configuration test (Minitest)
run: bundle exec rake test_configuration TEST_CONFIG_FREEZING=true
- name: Run Solid::Result.event_logs test (Minitest)
run: bundle exec rake test_event_logs_duration Solid_RESULT_TEST_EVENT_LOGS_DURATION=true
- name: Run tests (Minitest)
run: bundle exec rake test
- name: Run static code analysis (Rubocop)
run: bundle exec rake rubocop
- name: Run static type checking (Steep)
run: bundle exec steep check
if: ${{ matrix.ruby == 3.2 }}
- uses: paambaati/codeclimate-action@v5
if: ${{ matrix.ruby == 3.2 && !github.base_ref }}
solid-result-2.0.0/.gitignore 0000664 0000000 0000000 00000000146 14606620746 0016143 0 ustar 00root root 0000000 0000000 /.bundle/
/.yardoc
/_yardoc/
/coverage/
/doc/
/pkg/
/spec/reports/
/tmp/
Gemfile.lock
.ruby-version
solid-result-2.0.0/.rubocop.yml 0000664 0000000 0000000 00000003063 14606620746 0016426 0 ustar 00root root 0000000 0000000 inherit_from: .rubocop_todo.yml
require:
- rubocop-performance
- rubocop-minitest
- rubocop-rake
AllCops:
NewCops: enable
TargetRubyVersion: 2.7
Exclude:
- 'examples/**/*'
- 'vendor/**/*'
- 'spec/fixtures/**/*'
- 'tmp/**/*'
- '.git/**/*'
- 'bin/*'
Lint/RescueException:
Exclude:
- lib/solid/result/event_logs/tracking/enabled.rb
Layout/LineLength:
Max: 120
Layout/ExtraSpacing:
AllowBeforeTrailingComments: true
Layout/MultilineMethodCallIndentation:
Enabled: false
Lint/UnderscorePrefixedVariableName:
Enabled: false
Lint/UnusedMethodArgument:
Exclude:
- lib/solid/result/event_logs/listener.rb
Style/AccessModifierDeclarations:
Enabled: false
Style/CaseEquality:
Enabled: false
Style/ClassAndModuleChildren:
Enabled: false
Style/Lambda:
EnforcedStyle: literal
Style/ParallelAssignment:
Enabled: false
Style/SingleLineMethods:
Enabled: false
Style/MapToSet:
Enabled: false
Style/MixinGrouping:
Enabled: false
Naming/MethodName:
Enabled: false
Naming/VariableName:
Enabled: false
Metrics/BlockLength:
Exclude:
- solid-result.gemspec
- test/**/*.rb
Metrics/ClassLength:
Exclude:
- lib/solid/result/_self.rb
- test/**/*.rb
Metrics/AbcSize:
Exclude:
- lib/solid/result/event_logs/tracking/enabled.rb
Minitest/MultipleAssertions:
Enabled: false
Minitest/AssertEmptyLiteral:
Enabled: false
Minitest/AssertOperator:
Enabled: false
Minitest/AssertWithExpectedArgument:
Exclude:
- test/test_helper.rb
Naming/FileName:
Exclude:
- lib/solid-result.rb
solid-result-2.0.0/.rubocop_todo.yml 0000664 0000000 0000000 00000000755 14606620746 0017460 0 ustar 00root root 0000000 0000000 # This configuration was generated by
# `rubocop --auto-gen-config`
# on 2023-10-02 02:37:50 UTC using RuboCop version 1.56.3.
# The point is for the user to remove these configuration records
# one by one as the offenses are removed from the code base.
# Note that changes in the inspected code, or installation of new
# versions of RuboCop, may require this file to be generated again.
# Offense count: 24
# Configuration parameters: AllowedConstants.
Style/Documentation:
Enabled: false
solid-result-2.0.0/CHANGELOG.md 0000664 0000000 0000000 00000061143 14606620746 0015770 0 ustar 00root root 0000000 0000000 - [\[Unreleased\]](#unreleased)
- [2.0.0 - 2024-04-13](#200---2024-04-13)
- [Changed](#changed)
- [1.1.0 - 2024-03-25](#110---2024-03-25)
- [Added](#added)
- [1.0.0 - 2024-03-16](#100---2024-03-16)
- [Added](#added-1)
- [Changed](#changed-1)
- [\[0.13.0\] - 2024-02-01](#0130---2024-02-01)
- [Added](#added-2)
- [Changed](#changed-2)
- [\[0.12.0\] - 2024-01-07](#0120---2024-01-07)
- [Added](#added-3)
- [Changed](#changed-3)
- [\[0.11.0\] - 2024-01-02](#0110---2024-01-02)
- [Added](#added-4)
- [Changed](#changed-4)
- [\[0.10.0\] - 2023-12-31](#0100---2023-12-31)
- [Added](#added-5)
- [\[0.9.1\] - 2023-12-12](#091---2023-12-12)
- [Changed](#changed-5)
- [Fixed](#fixed)
- [\[0.9.0\] - 2023-12-12](#090---2023-12-12)
- [Added](#added-6)
- [Changed](#changed-6)
- [\[0.8.0\] - 2023-12-11](#080---2023-12-11)
- [Added](#added-7)
- [Changed](#changed-7)
- [Removed](#removed)
- [\[0.7.0\] - 2023-10-27](#070---2023-10-27)
- [Added](#added-8)
- [Changed](#changed-8)
- [\[0.6.0\] - 2023-10-11](#060---2023-10-11)
- [Added](#added-9)
- [Changed](#changed-9)
- [\[0.5.0\] - 2023-10-09](#050---2023-10-09)
- [Added](#added-10)
- [\[0.4.0\] - 2023-09-28](#040---2023-09-28)
- [Added](#added-11)
- [Changed](#changed-10)
- [Removed](#removed-1)
- [\[0.3.0\] - 2023-09-26](#030---2023-09-26)
- [Added](#added-12)
- [\[0.2.0\] - 2023-09-26](#020---2023-09-26)
- [Added](#added-13)
- [Removed](#removed-2)
- [\[0.1.0\] - 2023-09-25](#010---2023-09-25)
- [Added](#added-14)
## [Unreleased]
## 2.0.0 - 2024-04-13
### Changed
- **(BREAKING)** Rebrand the gem from `bcdd-result` to `Solid::Result`.
- `Solid::Result` replaces `BCDD::Result`.
- `Solid::Output` replaces `BCDD::Context`.
## 1.1.0 - 2024-03-25
### Added
- Add some Hash's methods to `BCDD::Context`. They are:
- `#slice` to extract only the desired keys.
- `#[]`, `#dig`, `#fetch` to access the values.
- `#values_at` and `#fetch_values` to get the values of the desired keys.
## 1.0.0 - 2024-03-16
### Added
- Add the `BCDD::Success` and `BCDD::Failure` modules. They are key to checking whether a result is a success or a failure independently of whether it is a `BCDD::Result` or a `BCDD::Context`.
- Add `BCDD::Result#type?` to check if the given type is the result type.
- Add `BCDD::Result#is?` as an alias for `BCDD::Result#type?`.
- Add `BCDD::Result#method_missing` to allow the type checking through method calls. For example, `result.ok?` will check if the result type is `:ok`.
> Note: All the methods above are available for the `BCDD::Context` as well.
### Changed
- **(BREAKING)** Replace transitions with event_logs concept.
- The `BCDD::Result::Transitions` module was renamed to `BCDD::Result::EventLogs`
- The `BCDD::Result.transitions` to `BCDD::Result.event_logs`.
- **(BREAKING)** Change `BCDD::Result#deconstruct_keys` to return a hash with the keys `:type` and `:value` when one of these keys is present. Otherwise, it will return the value itself.
- **(BREAKING)** Replace trasitions metadata `:ids_tree`, and `:ids_matrix` with `:ids` property. This property is a hash with the following keys:
- `:tree`, a graph/tree representation of the transitions ids.
- `:level_parent`, a hash with the level (depth) of each transition and its parent id.
- `:matrix`, a matrix representation of the transitions ids. It is a simplification of the `:tree` property.
- Transform `BCDD::Result::Context` into `BCDD::Context`. But a constant alias was added to keep the old name. You can use `BCDD::Result::Context` or `BCDD::Context` to access the same class.
## [0.13.0] - 2024-02-01
### Added
- `BCDD::Result::Context#and_expose` - Raise error when trying to expose an invalid key.
- `BCDD::Result.configuration` - Accept freeze option (default: `true`). When true, the configuration will be frozen after the block execution.
- `BCDD::Result.config.transitions` - Add transitions feature configuration.
- `config.transitions.listener =` - Set a listener to be called during the result transitions tracking. It must be a class that includes `BCDD::Result::Transitions::Listener`.
- `config.transitions.trace_id =` - Set a lambda (must have arity 0) to be called to get a trace id. Use to correlate different or the same operation (executed multiple times).
- Add transitions metadata property `:ids_matrix`. It is a simplification of the `:ids_tree` property. The matrix rows are the direct transitions from the root transition block, and the columns are the transitions nested from the direct transitions.
```ruby
# ids_matrix # {
0 | 1 | 2 | 3 | 4 # 0 => [0, 0],
- | - | - | - | - # 1 => [1, 1],
0 | | | | # 2 => [1, 2],
1 | 1 | 2 | | # 3 => [2, 1],
2 | 3 | | | # 4 => [3, 1],
3 | 4 | 5 | 6 | 7 # 5 => [3, 2],
4 | 8 | | | # 6 => [3, 3],
# 7 => [3, 4],
# 8 => [4, 1]
# }
```
- Add `BCDD::Result::Transitions::Listeners[]` - It creates a listener of listeners, which will be called in the order they were added.
### Changed
- **(BREAKING)** Rename `Given()` type from `:given` to `:_given_`.
- **(BREAKING)** Rename `Continue()` type from `:continued` to `:_continue_`.
- **(BREAKING)** Move transition `:source` from `:and_then` to `:result` property.
- **(BREAKING)** Rename transitions metadata property `:tree_map` to `:ids_tree`.
```ruby
# ids_tree #
0 # [0, [
|- 1 # [1, [[2, []]]],
| |- 2 # [3, []],
|- 3 # [4, [
|- 4 # [5, []],
| |- 5 # [6, [[7, []]]]
| |- 6 # ]],
| |- 7 # [8, []]
|- 8 # ]]
```
## [0.12.0] - 2024-01-07
### Added
- Add `BCDD::Result#and_then!` and `BCDD::Result::Context#and_then!` to execute a callable object (any object that responds to `#call`) to produce a result. The main difference between the `#and_then` and `#and_then!` is that the latter does not check the result source.
- **Attention:** to ensure the correct behavior, do not mix `#and_then` and `#and_then!` in the same result chain.
- This feature is turned off by default. You can enable it through the `BCDD::Result.config.feature.enable!(:and_then!)`.
- The method called by default (`:call`) can be changed through `BCDD::Result.config.and_then!.default_method_name_to_call=`.
### Changed
- **(BREAKING)** Renames the subject concept/term to `source`. When a mixin is included/extended, it defines the `Success()` and `Failure()` methods. Since the results are generated in a context (instance or singleton where the mixin was used), they will have a defined source (instance or singleton itself).
> Definition of source
>
> From dictionary:
> * a place, person, or thing from which something comes or can be obtained.
## [0.11.0] - 2024-01-02
### Added
- Add the `Given()` addon to produce a `Success(:given, value)` result. As the `Continue()` addon, it is ignored by the expectations. Use it to add a value to the result chain and invoke the next step (through `and_then`).
### Changed
- **(BREAKING)** Rename halted concept to terminal. Failures are terminal by default, but you can make a success terminal by enabling the `:continue` addon.
> Definition of terminal
>
> From dictionary:
> * of, forming, or situated at the end or extremity of something.
> * the end of a railroad or other transport route, or a station at such a point.
>
> From Wikipedia:
> * A "terminus" or "terminal" is a station at the end of a railway line.
- **(BREAKING)** Rename `BCDD::Result::Context::Success#and_expose` halted keyword argument to `terminal`.
- **(BREAKING)** Rename `BCDD::Result#halted?` to `BCDD::Result#terminal?`.
## [0.10.0] - 2023-12-31
### Added
- Add `BCDD::Result.transitions(&block)` to track all transitions in the same or between different operations. When there is a nesting of transition blocks, this mechanism will be able to correlate parent and child blocks and present the duration of all operations in milliseconds.
- Add `BCDD::Result.config.feature.disable!(:transitions)` and `BCDD::Result.config.feature.enable!(:transitions)` to turn on/off the `BCDD::Result.transitions` feature.
## [0.9.1] - 2023-12-12
### Changed
- **(BREAKING)** Make `BCDD::Result::Context::Success#and_expose()` to produce a terminal success by default. You can turn this off by passing `halted: false`.
### Fixed
- Make `BCDD::Result::Context#and_then(&block)` accumulate the result value.
## [0.9.0] - 2023-12-12
### Added
- Add new `BCDD::Result.config.constant_alias` options. `Context` and `BCDD::Context` are now available as aliases for `BCDD::Result::Context`.
```ruby
BCDD::Result.config.constant_alias.enable!('Context')
BCDD::Result.config.constant_alias.enable!('BCDD::Context')
```
- Add `BCDD::Result#halted?` to check if the result is halted. Failure results are halted by default, but you can halt a successful result by enabling the `:continue` addon.
### Changed
- **(BREAKING)** Change the `:continue` addon to halt the step chain on the first `Success()` result. So, if you want to advance to the next step, you must use `Continue(value)` instead of `Success(type, value)`. Otherwise, the step chain will be halted. (Implementation of the following proposal: https://github.com/B-CDD/result/issues/14)
- **(BREAKING)** Rename `BCDD::Result::Data#name` to `BCDD::Result::Data#kind`. The new word is more appropriate as it represents a result's kind (success or failure).
## [0.8.0] - 2023-12-11
### Added
- Add `BCDD::Result.config`
- **Feature**
```ruby
BCDD::Result.config.feature.options
BCDD::Result.config.feature.enabled?(:expectations)
BCDD::Result.config.feature.enable!(:expectations)
BCDD::Result.config.feature.disable!(:expectations)
```
- **Default Add-ons**
```ruby
BCDD::Result.config.addon.options
BCDD::Result.config.addon.enabled?(:continue)
BCDD::Result.config.addon.enable!(:continue)
BCDD::Result.config.addon.disable!(:continue)
```
- **Pattern matching**
```ruby
BCDD::Result.config.pattern_matching.options
BCDD::Result.config.pattern_matching.enabled?(:nil_as_valid_value_checking)
BCDD::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
BCDD::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
```
- **Constant Aliases**
```ruby
BCDD::Result.config.constant_alias.options
BCDD::Result.config.constant_alias.enabled?('Result')
BCDD::Result.config.constant_alias.enable!('Result')
BCDD::Result.config.constant_alias.disable!('Result')
```
- Add `BCDD::Result::configuration`. It freezes the configuration, disallowing methods that promote changes but allowing the query ones. You can use this feature to ensure integrity in your configuration.
```ruby
BCDD::Result.configuration do |config|
config.addon.enable!(:continue)
config.constant_alias.enable!('Result')
config.pattern_matching.disable!(:nil_as_valid_value_checking)
config.feature.disable!(:expectations) if ::Rails.env.production?
end
BCDD::Result.config.addon.enabled?(:continue) # true
BCDD::Result.config.constant_alias.enabled?('Result') # true
BCDD::Result.config.addon.disable!(:continue) # raises FrozenError
BCDD::Result.config.constant_alias.disable!('Result') # raises FrozenError
```
- Allow the pattern matching feature to be turned on/off through the `BCDD::Result::Expectations.mixin`. Now, it can be used without enabling it for the whole project.
```ruby
extend BCDD::Result::Expectations.mixin(
config: {
addon: { continue: false },
pattern_matching: { nil_as_valid_value_checking: true },
},
success: {
numbers: ->(value) { value => [Numeric, Numeric] },
division_completed: Numeric
},
failure: {
invalid_arg: String,
division_by_zero: String
}
)
```
### Changed
- **(BREAKING)** Replace `BCDD::Result::Contract.nil_as_valid_value_checking!` with `BCDD::Result::Config.pattern_matching.enable!(:nil_as_valid_value_checking)`.
- **(BREAKING)** Replace `BCDD::Result::Contract.nil_as_valid_value_checking?` with `BCDD::Result::Config.pattern_matching.enabled?(:nil_as_valid_value_checking)`.
- **(BREAKING)** Replace `mixin(with:)` with `mixin(config:)` keyword argument.
- **(BREAKING)** Change the addons definition.
- **From**
```ruby
BCDD::Result.mixin(with: :Continue)
BCDD::Result.mixin(with: [:Continue])
```
- **To**
```ruby
BCDD::Result.mixin(config: { addon: { continue: true } })
```
- These examples are valid to all kinds of mixins (`BCDD::Result.mixin`, `BCDD::Result::Context.mixin`, `BCDD::Result::Expectations.mixin`, `BCDD::Result::Context::Expectations.mixin`)
### Removed
- **(BREAKING)** Remove the `lib/result` file. Now you can define `Result` as an alias for `BCDD::Result` using `BCDD::Result::Config.constant_alias.enable!('Result')`.
## [0.7.0] - 2023-10-27
### Added
- Add `BCDD::Result::Context`. It is a `BCDD::Result`, meaning it has all the features of the `BCDD::Result`. The main difference is that it only accepts keyword arguments as a value, which applies to the `and_then`: The called methods must receive keyword arguments, and the dependency injection will be performed through keyword arguments.
As the input/output are hashes, the results of each `and_then` call will automatically accumulate. This is useful in operations chaining, as the result of the previous operations will be automatically available for the next one. Because of this behavior, the `BCDD::Result::Context` has the `#and_expose` method to expose only the desired keys from the accumulated result.
- Add `BCDD::Result::Context::Expectations.new` and `BCDD::Result::Context::Expectations.mixin`. Both are similar to `BCDD::Result::Expectations.new` and `BCDD::Result::Expectations.mixin`, but they are for `BCDD::Result::Context` instead of `BCDD::Result`.
- The `BCDD::Result::Context.mixin` and `BCDD::Result::Context::Expectations.mixin` support the `with: :Continue` option.
- Enhance Pattern Matching support. When a `NoMatchingPatternError` occurs inside a value checking, the `BCDD::Result::Contract::Error::UnexpectedValue` message will include the value and the expected patterns.
- Add `BCDD::Result::Success::Methods` to be share common methods between `BCDD::Result::Success` and `BCDD::Result::Context::Success`.
- Add `BCDD::Result::Failure::Methods` to be share common methods between `BCDD::Failure::Success` and `BCDD::Result::Context::Failure`.
- Make all mixin generators produce a named module. The module name will be added to the target class/module (who included/extended a `BCDD::Result`/`BCDD::Result::Context` mixin module).
- Add `BCDD::Result::Contract.nil_as_valid_value_checking!`. Please use this method when using the one-line pattern-matching operators on the result's value expectations.
### Changed
- **(BREAKING)** Rename `BCDD::Result::WrongResultSubject` to `BCDD::Result::Error::InvalidResultSubject`.
- **(BREAKING)** Rename `BCDD::Result::WrongSubjectMethodArity` to `BCDD::Result::Error::InvalidSubjectMethodArity`.
- **(BREAKING)** Rename the constant produced by `BCDD::Result::Expectations.mixins` from `Expected` to `Result`.
- Extract the major part of the `BCDD::Result::Expectations` components/features to `BCDD::Result::Contract`.
- **(BREAKING)** `BCDD::Result::Expectations::Error` became `BCDD::Result::Contract::Error`. So, `BCDD::Result::Expectations::Error::UnexpectedType` and `BCDD::Result::Expectations::Error::UnexpectedValue` are now `BCDD::Result::Contract::Error::UnexpectedType` and `BCDD::Result::Contract::Error::UnexpectedValue`.
## [0.6.0] - 2023-10-11
### Added
- Add `BCDD::Result.mixin` to be included or extended in any object. It will add `Success()` and `Failure()` to the target object (the object who receives the include/extend).
- Add `BCDD::Result.mixin(with: :Continue)`. This addon will add a `Continue(value)` method to the target object to produce a `Success(:continued, value)` result.
- Add `BCDD::Result::Expectations.mixin(with: :Continue)`, it is similar to `BCDD::Result.mixin(with: :Continue)`, the key difference is that the `Continue(value)` will be ignored by the expectations. This is extremely useful when you want to use `Continue(value)` to chain operations, but you don't want to declare N success types in the expectations.
- Increase the arity of `BCDD::Result#and_then`. Now, it can receive a second argument (a value to be injected and shared with the subject's method).
- Increase the arity (maximum of 2) for the methods called through `BCDD::Result#and_then`. The second argument is the value injected by `BCDD::Result#and_then`.
### Changed
- **(BREAKING)** Make `BCDD::Result::Mixin` be a private constant. The `BCDD::Result.mixin` method is the new way to use it.
## [0.5.0] - 2023-10-09
### Added
- Add `BCDD::Result::Expectations` to define contracts for your results. There are two ways to use it: the standalone (`BCDD::Result::Expectations.new`) and the mixin (`BCDD::Result::Expectations.mixin`) mode.
The main difference is that the mixin mode will use the target object (who receives the include/extend) as the result's subject (like the `BCDD::Result::Mixin` does), while the standalone mode won't.
**Standalone mode:**
```ruby
module Divide
Expected = BCDD::Result::Expectations.new(
success: {
numbers: ->(value) { value.is_a?(Array) && value.size == 2 && value.all?(Numeric) },
division_completed: Numeric
},
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def self.call(arg1, arg2)
arg1.is_a?(Numeric) or return Expected::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Expected::Failure(:invalid_arg, 'arg2 must be numeric')
arg2.zero? and return Expected::Failure(:division_by_zero, 'arg2 must not be zero')
Expected::Success(:division_completed, arg1 / arg2)
end
end
```
**Mixin mode:**
```ruby
class Divide
include BCDD::Result::Expectations.mixin(
success: {
numbers: ->(value) { value.is_a?(Array) && value.size == 2 && value.all?(Numeric) },
division_completed: Numeric
},
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
```
## [0.4.0] - 2023-09-28
### Added
- Add `require 'result'` to define `Result` as an alias for `BCDD::Result`.
- Add support to pattern matching (Ruby 2.7+).
- Add `BCDD::Result#on_unknown` to execute a block if no other hook (`#on`, `#on_type`, `#on_failure`, `#on_success`) has been executed. Attention: always use it as the last hook.
- Add `BCDD::Result::Handler#unknown` to execute a block if no other handler (`#[]`, `#type`, `#failure`, `#success`) has been executed. Attention: always use it as the last handler.
### Changed
- **(BREAKING)** Rename `BCDD::Resultable` to `BCDD::Result::Mixin`.
- **(BREAKING)** Change `BCDD::Result#data` to return a `BCDD::Result::Data` instead of the result value. This object exposes the result attributes (name, type, value) directly and as a hash (`to_h`/`to_hash`) and array (`to_a`/`to_ary`).
### Removed
- **(BREAKING)** Remove `BCDD::Result#data_or`.
## [0.3.0] - 2023-09-26
### Added
- Add `BCDD::Result#handle`. This method allows defining blocks for each hook (type, failure, success), but instead of returning the result itself, it will return the output of the first match/block execution.
## [0.2.0] - 2023-09-26
### Added
- Add `BCDD::Resultable`. This module can add `Success()` and `Failure()` in any object. The target object will be the subject of the result object produced by these methods.
**Classes (instance methods)**
```ruby
class Divide
include BCDD::Resultable
attr_reader :arg1, :arg2
def initialize(arg1, arg2)
@arg1 = arg1
@arg2 = arg2
end
def call
validate_numbers
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
```
**Module (singleton methods)**
```ruby
module Divide
extend self, BCDD::Resultable
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
```
- Make the `BCDD::Result#initialize` enabled to receive a subject.
- Make the `BCDD::Result#and_then` method receive a method name (symbol) and perform it on the result subject (added by `BCDD::Resultable`). The called method must return a result; otherwise, an error (`BCDD::Result::Error::UnexpectedOutcome`) will be raised.
- Add `BCDD::Result::Error::UnexpectedOutcome` to represent an unexpected outcome.
- Add `BCDD::Result::Error::WrongResultSubject` to represent a wrong result subject. When using `BCDD::Resultable`, the result subject must be the same as the target object.
- Add `BCDD::Result::Error::WrongSubjectMethodArity` to represent a wrong subject method arity. Valid arities are 0 and 1.
### Removed
- **(BREAKING)** Remove `BCDD::Result::Error::UnexpectedBlockOutcome`. It was replaced by `BCDD::Result::Error::UnexpectedOutcome`.
## [0.1.0] - 2023-09-25
### Added
- Add `BCDD::Result` to represent a result.
- Add `BCDD::Result#type` to get the result type. The type must be a symbol.
- Add `BCDD::Result#value` to get the result value. The value can be anything.
- Add `BCDD::Result#success?` to check if the result is a success. You can also check the result type by passing an argument to it. For example, `result.success?(:ok)` will check if the result is a success and if the type is `:ok`.
- Add `BCDD::Result#failure?` to check if the result is a failure. You can also check the result type by passing an argument to it. For example, `result.failure?(:error)` will check if the result is a failure and if the type is `:error`.
- Add `BCDD::Result#value_or` to get the value of a successful result or a default value (from the block) if it is a failure.
- Add `BCDD::Result#==` to compare two results.
- Add `BCDD::Result#eql?` to compare two results.
- Add `BCDD::Result#hash` to get the hash of a result.
- Add `BCDD::Result#inspect` to get the string representation of a result.
- Add `BCDD::Result#on` to execute a block depending on the result type (independently of the result being a success or a failure). The block will receive the result value as an argument, and the result itself will be returned after (or not) the block execution. The method can be called multiple times and with one or more arguments. For example, `result.on(:ok, :error) { |value| # ... }` will execute the block if the result type is `:ok` or `:error`.
- Add `BCDD::Result#on_success` to execute a block if the result is a success. It works like `BCDD::Result#on` but only for success results.
- Add `BCDD::Result#on_failure` to execute a block if the result is a failure. It works like `BCDD::Result#on` but only for failure results.
- Add `BCDD::Result#and_then` to execute the block if the result is a success. You can use it to chain multiple operations. If the block returns a failure result and there are other `and_then` calls after it, the next blocks will be skipped.
- Add `BCDD::Result#data` as an alias for `BCDD::Result#value`.
- Add `BCDD::Result#data_or` as an alias for `BCDD::Result#value_or`.
- Add `BCDD::Result#on_type` as an alias for `BCDD::Result#on`.
- Add `BCDD::Result::Success()` to factory a success result.
- Add `BCDD::Result::Failure()` to factory a failure result.
solid-result-2.0.0/CODE_OF_CONDUCT.md 0000664 0000000 0000000 00000012151 14606620746 0016751 0 ustar 00root root 0000000 0000000 # Contributor Covenant Code of Conduct
## Our Pledge
We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
## Our Standards
Examples of behavior that contributes to a positive environment for our community include:
* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
* Focusing on what is best not just for us as individuals, but for the overall community
Examples of unacceptable behavior include:
* The use of sexualized language or imagery, and sexual attention or
advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
## Scope
This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at rodrigo.serradura@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the reporter of any incident.
## Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
### 1. Correction
**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
### 2. Warning
**Community Impact**: A violation through a single incident or series of actions.
**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
### 3. Temporary Ban
**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
### 4. Permanent Ban
**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
**Consequence**: A permanent ban from any sort of public interaction within the community.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.
solid-result-2.0.0/Gemfile 0000664 0000000 0000000 00000000742 14606620746 0015450 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
source 'https://rubygems.org'
# Specify your gem's dependencies in solid-result.gemspec
gemspec
gem 'rake', '~> 13.1'
gem 'minitest', '~> 5.20'
gem 'mocha', '~> 2.1', require: false
gem 'rubocop', '~> 1.58', '>= 1.58.0'
gem 'rubocop-minitest', '~> 0.33.0'
gem 'rubocop-performance', '~> 1.19', '>= 1.19.1'
gem 'rubocop-rake', '~> 0.6.0'
gem 'simplecov', '~> 0.22.0', require: false
gem 'steep', '~> 1.6', require: false if RUBY_VERSION >= '3.0'
solid-result-2.0.0/LICENSE.txt 0000664 0000000 0000000 00000002074 14606620746 0016000 0 ustar 00root root 0000000 0000000 The MIT License (MIT)
Copyright (c) 2023 Rodrigo Serradura
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
solid-result-2.0.0/README.md 0000664 0000000 0000000 00000256630 14606620746 0015445 0 ustar 00root root 0000000 0000000
🔀 Solid::Result
Unleash a pragmatic and observable use of Result Pattern and Railway-Oriented Programming in Ruby.
It's a general-purpose result monad that allows you to create objects representing a success (`Solid::Result::Success`) or failure (`Solid::Result::Failure`).
**What problem does it solve?**
It allows you to consistently represent the concept of success and failure throughout your codebase.
Furthermore, this abstraction exposes several features that will be useful to make the application flow react cleanly and securely to the result represented by these objects.
Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofit.com/rop/) pattern (superpower) in your code.
- [Supported Ruby](#supported-ruby)
- [Installation](#installation)
- [Usage](#usage)
- [`Solid::Result` *versus* `Result`](#solidresult-versus-result)
- [Reference](#reference)
- [Basic methods](#basic-methods)
- [Checking types with `result.is?` or `method missing`](#checking-types-with-resultis-or-method-missing)
- [Checking types with `result.success?` or `result.failure?`](#checking-types-with-resultsuccess-or-resultfailure)
- [Result Hooks](#result-hooks)
- [`result.on`](#resulton)
- [`result.on_type`](#resulton_type)
- [`result.on_success`](#resulton_success)
- [`result.on_failure`](#resulton_failure)
- [`result.on_unknown`](#resulton_unknown)
- [`result.handle`](#resulthandle)
- [Result Value](#result-value)
- [`result.value_or`](#resultvalue_or)
- [Result Data](#result-data)
- [`result.data`](#resultdata)
- [Railway Oriented Programming](#railway-oriented-programming)
- [`result.and_then`](#resultand_then)
- [`Solid::Result.mixin`](#solidresultmixin)
- [Class example (Instance Methods)](#class-example-instance-methods)
- [Module example (Singleton Methods)](#module-example-singleton-methods)
- [Important Requirement](#important-requirement)
- [Dependency Injection](#dependency-injection)
- [Add-ons](#add-ons)
- [`Solid::Result::Expectations`](#solidresultexpectations)
- [Standalone *versus* Mixin mode](#standalone-versus-mixin-mode)
- [Type checking - Result Hooks](#type-checking---result-hooks)
- [`#success?` and `#failure?`](#success-and-failure)
- [`#on` and `#on_type`](#on-and-on_type)
- [`#on_success` and `#on_failure`](#on_success-and-on_failure)
- [`#handle`](#handle)
- [Type checking - Result Creation](#type-checking---result-creation)
- [Mixin mode](#mixin-mode)
- [Standalone mode](#standalone-mode)
- [Value checking - Result Creation](#value-checking---result-creation)
- [Success()](#success)
- [Failure()](#failure)
- [Pattern Matching Support](#pattern-matching-support)
- [`Solid::Result::Expectations.mixin` add-ons](#solidresultexpectationsmixin-add-ons)
- [`Solid::Output`](#solidoutput)
- [Defining successes and failures](#defining-successes-and-failures)
- [Hash methods](#hash-methods)
- [`Solid::Output.mixin`](#solidoutputmixin)
- [Class example (Instance Methods)](#class-example-instance-methods-1)
- [`and_expose`](#and_expose)
- [Module example (Singleton Methods)](#module-example-singleton-methods-1)
- [`Solid::Output::Expectations`](#solidoutputexpectations)
- [Mixin add-ons](#mixin-add-ons)
- [Pattern Matching](#pattern-matching)
- [`Solid::Result`](#solidresult)
- [`Array`/`Find` patterns](#arrayfind-patterns)
- [`Hash` patterns](#hash-patterns)
- [`Solid::Output`](#solidoutput-1)
- [`Array`/`Find` patterns](#arrayfind-patterns-1)
- [`Hash` patterns](#hash-patterns-1)
- [How to pattern match without the concept of success and failure](#how-to-pattern-match-without-the-concept-of-success-and-failure)
- [`Solid::Result.event_logs`](#solidresultevent_logs)
- [`metadata: {ids:}`](#metadata-ids)
- [Configuration](#configuration)
- [Turning on/off](#turning-onoff)
- [Setting a `trace_id` fetcher](#setting-a-trace_id-fetcher)
- [Setting a `listener`](#setting-a-listener)
- [Setting multiple `listeners`](#setting-multiple-listeners)
- [`Solid::Result.configuration`](#solidresultconfiguration)
- [`Solid::Result.config`](#solidresultconfig)
- [`Solid::Result#and_then!`](#solidresultand_then)
- [Dependency Injection](#dependency-injection-1)
- [Configuration](#configuration-1)
- [Analysis: Why is `and_then!` an Anti-pattern?](#analysis-why-is-and_then-an-anti-pattern)
- [`#and_then` versus `#and_then!`](#and_then-versus-and_then)
- [Analysis: Why is `#and_then` the antidote/standard?](#analysis-why-is-and_then-the-antidotestandard)
- [About](#about)
- [Development](#development)
- [Contributing](#contributing)
- [License](#license)
- [Code of Conduct](#code-of-conduct)
## Supported Ruby
This library is tested against:
Version | 2.7 | 3.0 | 3.1 | 3.2 | 3.3 | Head
---- | --- | --- | --- | --- | --- | ---
100% Coverage | ✅ | ✅ | ✅ | ✅ | ✅ | ✅
## Installation
Add this line to your application's Gemfile:
```ruby
gem 'solid-result'
```
And then execute:
$ bundle install
If bundler is not being used to manage dependencies, install the gem by executing:
$ gem install solid-result
And require it in your code:
require 'solid/result'
⬆️ back to top
## Usage
To create a result, you must define a type (symbol) and its value (any kind of object). e.g.,
```ruby
Solid::Result::Success(:ok, :1) #
# The value can be any kind of object
Solid::Result::Failure(:err, 'the value') #
```
The reason for defining a `type` is that it is very common for a method/operation to return different types of successes or failures. Because of this, the `type` will always be required. e,g.,
```ruby
Solid::Result::Success(:ok) #
# The type is mandatory and the value is optional
Solid::Result::Failure(:err) #
```
⬆️ back to top
#### `Solid::Result` *versus* `Result`
This gem provides a way to create constant aliases for `Solid::Result` and other classes/modules.
To enable it, you must call the `Solid::Result.configuration` method and pass a block to it. You can turn the aliases you want on/off in this block.
```ruby
Solid::Result.configuration do |config|
config.constant_alias.enable!('Result')
end
```
So, instead of using `Solid::Result` everywhere, you can use `Result` as an alias/shortcut.
```ruby
Result::Success(:ok) #
Result::Failure(:err) #
```
If you have enabled constant aliasing, all examples in this README that use `Solid::Result` can be implemented using `Result`.
There are other aliases and configurations available. Check the [Solid::Result.configuration]() section for more information.
⬆️ back to top
## Reference
### Basic methods
Both `Solid::Result::Success` and `Solid::Result::Failure` are composed of the same methods. Look at the basic ones:
**Solid::Result::Success**
```ruby
################
# With a value #
################
result = Solid::Result::Success(:ok, my: 'value')
result.success? # true
result.failure? # false
result.type?(:ok) # true
result.type # :ok
result.value # {:my => "value"}
###################
# Without a value #
###################
result = Solid::Result::Success(:yes)
result.success? # true
result.failure? # false
result.type?(:yes) # true
result.type # :yes
result.value # nil
```
**Solid::Result::Failure**
```ruby
################
# With a value #
################
result = Solid::Result::Failure(:err, 'my_value')
result.success? # false
result.failure? # true
result.type?(:err) # true
result.type # :err
result.value # "my_value"
###################
# Without a value #
###################
result = Solid::Result::Failure(:no)
result.success? # false
result.failure? # true
result.type?(:no) # true
result.type # :no
result.value # nil
```
In both cases, the `type` must be a symbol, and the `value` can be any kind of object.
⬆️ back to top
#### Checking types with `result.is?` or `method missing`
Beyond the `type?` method, you can also use the `is?` method to check the result type. If you want to check the type directly, you can write the type using a method that ends with a question mark.
```ruby
result = Solid::Result::Success(:ok)
result.is?(:ok) # true
result.ok? # true
result = Solid::Result::Failure(:err)
result.is?(:err) # true
result.err? # true
```
⬆️ back to top
#### Checking types with `result.success?` or `result.failure?`
`Solid::Result#success?` and `Solid::Result#failure?` are methods that allow you to check if the result is a success or a failure.
You can also check the result type by passing an argument to it. For example, `result.success?(:ok)` will check if the result is a success and if the type is `:ok`.
```ruby
result = Solid::Result::Success(:ok)
result.success?(:ok)
# This is the same as:
result.success? && result.type == :ok
```
The same is valid for `Solid::Result#failure?`.
```ruby
result = Solid::Result::Failure(:err)
result.failure?(:err)
# This is the same as:
result.failure? && result.type == :err
```
⬆️ back to top
### Result Hooks
Result hooks are methods that allow you to execute a block of code based on the type of result obtained.
To demonstrate their use, I will implement a method that can divide two numbers.
```ruby
def divide(arg1, arg2)
arg1.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Solid::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Solid::Result::Success(:division_completed, arg1 / arg2)
end
```
⬆️ back to top
#### `result.on`
When you use `Solid::Result#on`, the block will be executed only when the type matches the result type.
However, even if the block is executed, the method will always return the result itself.
The value of the result will be available as the first argument of the block.
```ruby
result = divide(nil, 2)
#
output =
result
.on(:invalid_arg) { |msg| puts msg }
.on(:division_by_zero) { |msg| puts msg }
.on(:division_completed) { |number| puts number }
# The code above will print 'arg1 must be numeric' and return the result itself.
result.object_id == output.object_id # true
```
You can define multiple types to be handled by the same hook/block
```ruby
result = divide(4, 0)
output =
result.on(:invalid_arg, :division_by_zero, :division_completed) { |value| puts value }
# The code above will print 'arg2 must not be zero' and return the result itself.
result.object_id == output.object_id # true
```
*PS: The `divide()` implementation is [here](#result-hooks).*
⬆️ back to top
#### `result.on_type`
`Solid::Result#on_type` is an alias of `Solid::Result#on`.
```ruby
result = divide(nil, 2)
#
output =
result
.on_type(:invalid_arg, :division_by_zero) { |msg| puts msg }
.on_type(:division_completed) { |number| puts number }
# The code above will print 'arg1 must be numeric' and return the result itself.
result.object_id == output.object_id # true
```
*PS: The `divide()` implementation is [here](#result-hooks).*
⬆️ back to top
#### `result.on_success`
The `Solid::Result#on_success` method is quite similar to the `Solid::Result#on` hook, but with a few key differences:
1. It will only execute the block of code if the result is a success.
2. If the type declaration is not included, the method will execute the block for any successful result, regardless of its type.
```ruby
# In both examples, it executes the block and returns the result itself.
divide(4, 2).on_success { |number| puts number }
divide(4, 2).on_success(:division_completed) { |number| puts number }
# It doesn't execute the block as the type is different.
divide(4, 4).on_success(:ok) { |value| puts value }
# It doesn't execute the block, as the result is a success, but the hook expects a failure.
divide(4, 4).on_failure { |error| puts error }
```
*PS: The `divide()` implementation is [here](#result-hooks).*
⬆️ back to top
#### `result.on_failure`
It is the opposite of `Result#on_success`:
1. It will only execute the block of code if the result is a failure.
2. If the type declaration is not included, the method will execute the block for any failed result, regardless of its type.
```ruby
# In both examples, it executes the block and returns the result itself.
divide(nil, 2).on_failure { |error| puts error }
divide(4, 0).on_failure(:division_by_zero) { |error| puts error }
# It doesn't execute the block as the type is different.
divide(4, 0).on_failure(:invalid_arg) { |error| puts error }
# It doesn't execute the block, as the result is a failure, but the hook expects a success.
divide(4, 0).on_success { |number| puts number }
```
*PS: The `divide()` implementation is [here](#result-hooks).*
⬆️ back to top
#### `result.on_unknown`
`Solid::Result#on_unknown` will execute the block when no other hook (`#on`, `#on_type`, `#on_failure`, `#on_success`) has been executed.
Regardless of the block being executed, the method will always return the result itself.
The value of the result will be available as the first argument of the block.
```ruby
divide(4, 2)
.on(:invalid_arg) { |msg| puts msg }
.on(:division_by_zero) { |msg| puts msg }
.on_unknown { |value, type| puts [type, value].inspect }
# The code above will print '[:division_completed, 2]' and return the result itself.
```
*PS: The `divide()` implementation is [here](#result-hooks).*
⬆️ back to top
#### `result.handle`
This method lets you define blocks for each hook (type, failure, or success), but instead of returning itself, it will return the output of the first match/block execution.
```ruby
divide(4, 2).handle do |result|
result.success { |number| number }
result.failure(:invalid_arg) { |err| puts err }
result.type(:division_by_zero) { raise ZeroDivisionError }
result.unknown { raise NotImplementedError }
end
#or
divide(4, 2).handle do |on|
on.success { |number| number }
on.failure { |err| puts err }
on.unknown { raise NotImplementedError }
end
#or
divide(4, 2).handle do |on|
on.type(:invalid_arg) { |err| puts err }
on.type(:division_by_zero) { raise ZeroDivisionError }
on.type(:division_completed) { |number| number }
on.unknown { raise NotImplementedError }
end
# or
divide(4, 2).handle do |on|
on[:invalid_arg] { |err| puts err }
on[:division_by_zero] { raise ZeroDivisionError }
on[:division_completed] { |number| number }
on.unknown { raise NotImplementedError }
end
# The [] syntax 👆 is an alias of #type.
```
**Notes:**
* You can define multiple types to be handled by the same hook/block
* If the type is missing, it will execute the block for any success or failure handler.
* The `#type` and `#[]` handlers require at least one type/argument.
*PS: The `divide()` implementation is [here](#result-hooks).*
⬆️ back to top
### Result Value
To access the result value, you can simply call `Solid::Result#value`.
However, there may be instances where you need to retrieve the value of a successful result or a default value if the result is a failure. In such cases, you can make use of `Solid::Result#value_or`.
#### `result.value_or`
`BCCD::Result#value_or` returns the value when the result is a success. However, if it is a failure, the given block will be executed, and its outcome will be returned.
```ruby
def divide(arg1, arg2)
arg1.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg)
arg2.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg)
return Solid::Result::Failure(:division_by_zero) if arg2.zero?
Solid::Result::Success(:division_completed, arg1 / arg2)
end
# When the result is success
divide(4, 2).value_or { 0 } # 2
# When the result is failure
divide('4', 2).value_or { 0 } # 0
divide(4, '2').value_or { 0 } # 0
divide(100, 0).value_or { 0 } # 0
```
*PS: The `divide()` implementation is [here](#result-hooks).*
⬆️ back to top
### Result Data
#### `result.data`
The `Solid::Result#data` exposes the result attributes (kind, type, value) directly and as a hash (`to_h`/`to_hash`) and array (`to_a`/`to_ary`).
This is helpful if you need to access the result attributes generically or want to use Ruby features like splat (`*`) and double splat (`**`) operators.
See the examples below to understand how to use it.
```ruby
result = Solid::Result::Success(:ok, 1)
success_data = result.data # #
success_data.kind # :success
success_data.type # :ok
success_data.value # 1
success_data.to_h # {:kind=>:success, :type=>:ok, :value=>1}
success_data.to_a # [:success, :ok, 1]
kind, type, value = success_data
[kind, type, value] # [:success, :ok, 1]
def print_to_ary(kind, type, value)
puts [kind, type, value].inspect
end
def print_to_hash(kind:, type:, value:)
puts [kind, type, value].inspect
end
print_to_ary(*success_data) # [:success, :ok, 1]
print_to_hash(**success_data) # [:success, :ok, 1]
```
> **NOTE:** The example above uses a success result, but the same is valid for a failure result.
⬆️ back to top
### Railway Oriented Programming
["Railway Oriented Programming (ROP)"](https://fsharpforfunandprofit.com/rop/) is a programming technique that involves linking blocks together to form a sequence of operations, also known as a pipeline.
If a failure occurs in any of the blocks, the pipeline is interrupted and subsequent blocks are skipped.
The ROP technique allows you to structure your code in a way that expresses your logic as a series of operations, with the added benefit of stopping the process at the first detection of failure.
If all blocks successfully execute, the final result of the pipeline will be a success.
#### `result.and_then`
```ruby
module Divide
extend self
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg2 must be numeric')
Solid::Result::Success(:ok, [arg1, arg2])
end
def validate_nonzero(numbers)
return Solid::Result::Success(:ok, numbers) if numbers.last.nonzero?
Solid::Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Solid::Result::Success(:division_completed, number1 / number2)
end
end
```
Example of outputs:
```ruby
Divide.call('4', 2)
#
Divide.call(2, '2')
#
Divide.call(2, 0)
#
Divide.call(2, 2)
#
```
⬆️ back to top
#### `Solid::Result.mixin`
This method generates a module that any object can include or extend. It adds two methods to the target object: `Success()` and `Failure()`.
The main difference between these methods and `Solid::Result::Success()`/`Solid::Result::Failure()` is that the former will utilize the target object (which has received the include/extend) as the result's source.
Because the result has a source, the `#and_then` method can call methods from it.
##### Class example (Instance Methods)
```ruby
class Divide
include Solid::Result.mixin
attr_reader :arg1, :arg2
def initialize(arg1, arg2)
@arg1 = arg1
@arg2 = arg2
end
def call
validate_numbers
.and_then(:validate_nonzero)
.and_then(:divide)
end
private
def validate_numbers
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
# As arg1 and arg2 are instance methods, they will be available in the instance scope.
# So, in this case, I'm passing them as an array to show how the next method can receive the value as its argument.
Success(:ok, [arg1, arg2])
end
def validate_nonzero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
Divide.new(4, 2).call #
Divide.new(4, 0).call #
Divide.new('4', 2).call #
Divide.new(4, '2').call #
```
##### Module example (Singleton Methods)
```ruby
module Divide
extend self, Solid::Result.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_nonzero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
Divide.call(4, 2) #
Divide.call(4, 0) #
Divide.call('4', 2) #
Divide.call(4, '2') #
```
⬆️ back to top
##### Important Requirement
To use the `#and_then` method to call methods, they must use `Success()` and `Failure()` to produce the results.
If you try to use `Solid::Result::Success()`/`Solid::Result::Failure()`, or results from another `Solid::Result.mixin` instance with `#and_then`, it will raise an error because the sources are different.
**Note:** You can still use the block syntax, but all the results must be produced by the source's `Success()` and `Failure()` methods.
```ruby
module ValidateNonzero
extend self, Solid::Result.mixin
def call(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
end
module Divide
extend self, Solid::Result.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_nonzero(numbers)
ValidateNonzero.call(numbers) # This will raise an error
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
```
Look at the error produced by the code above:
```ruby
Divide.call(2, 0)
# You cannot call #and_then and return a result that does not belong to the same source! (Solid::Result::Error::InvalidResultSource)
# Expected source: Divide
# Given source: ValidateNonzero
# Given result: #
```
In order to fix this, you must handle the result produced by `ValidateNonzero.call()` and return a result that belongs to the same source.
```ruby
module ValidateNonzero
extend self, Solid::Result.mixin
def call(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
end
module Divide
extend self, Solid::Result.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_nonzero(numbers)
# In this case we are handling the result from other source
# and returning our own
ValidateNonzero.call(numbers).handle do |on|
on.success { |numbers| Success(:ok, numbers) }
on.failure { |err| Failure(:division_by_zero, err) }
end
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
```
Look at the output of the code above:
```ruby
Divide.call(2, 0)
#
```
⬆️ back to top
##### Dependency Injection
The `Solid::Result#and_then` accepts a second argument that will be used to share a value with the source's method.
To receive this argument, the source's method must have an arity of two, where the first argument will be the result value and the second will be the injected value.
```ruby
require 'logger'
module Divide
extend self, Solid::Result.mixin
def call(arg1, arg2, logger: ::Logger.new(STDOUT))
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero, logger)
.and_then(:divide, logger)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_nonzero(numbers, logger)
if numbers.last.zero?
logger.error('arg2 must not be zero')
Failure(:division_by_zero, 'arg2 must not be zero')
else
logger.info('The numbers are valid')
Success(:ok, numbers)
end
end
def divide((number1, number2), logger)
division = number1 / number2
logger.info("The division result is #{division}")
Success(:division_completed, division)
end
end
Divide.call(4, 2)
# I, [2023-10-11T00:08:05.546237 #18139] INFO -- : The numbers are valid
# I, [2023-10-11T00:08:05.546337 #18139] INFO -- : The division result is 2
#=> #
Divide.call(4, 2, logger: Logger.new(IO::NULL))
#=> #
```
⬆️ back to top
##### Add-ons
The `Solid::Result.mixin` also accepts the `config:` argument. It is a hash that will be used to define custom behaviors for the mixin.
**given**
This addon is enabled by default. It will create the `Given(value)` method. Use it to add a value to the result chain and invoke the next step (through `and_then`).
You can turn it off by passing `given: false` to the `config:` argument or using the `Solid::Result.configuration`.
**continue**
This addon will create the `Continue(value)` method and change the `Success()` behavior to terminate the step chain.
So, if you want to advance to the next step, you must use `Continue(value)` instead of `Success(type, value)`. Otherwise, the step chain will be terminated.
In this example below, the `validate_nonzero` will return a `Success(:division_completed, 0)` and terminate the chain if the first number is zero.
```ruby
module Divide
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given([arg1, arg2])
.and_then(:validate_numbers)
.and_then(:validate_nonzero)
.and_then(:divide)
end
private
def validate_numbers(numbers)
number1, number2 = numbers
number1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
number2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue(numbers)
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'arg2 must not be zero') if numbers.last.zero?
return Success(:division_completed, 0) if numbers.first.zero?
Continue(numbers)
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
```
⬆️ back to top
### `Solid::Result::Expectations`
This feature lets you define contracts for your results' types and values. There are two ways to use it: the standalone (`Solid::Result::Expectations.new`) and the mixin (`Solid::Result::Expectations.mixin`) mode.
It was designed to ensure all the aspects of the result's type and value. So, an error will be raised if you try to create or handle a result with an unexpected type or value.
#### Standalone *versus* Mixin mode
The _**standalone mode**_ creates an object that knows how to produce and validate results based on the defined expectations. Look at the example below:
```ruby
module Divide
Result = Solid::Result::Expectations.new(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
def self.call(arg1, arg2)
arg1.is_a?(Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
arg2.zero? and return Result::Failure(:division_by_zero, 'arg2 must not be zero')
Result::Success(:division_completed, arg1 / arg2)
end
end
```
In the code above, we define a constant `Divide::Result`. And because of this (it is a constant), we can use it inside and outside the module.
Look what happens if you try to create a result without one of the expected types.
```ruby
Divide::Result::Success(:ok)
# type :ok is not allowed. Allowed types: :numbers, :division_completed
# (Solid::Result::Contract::Error::UnexpectedType)
Divide::Result::Failure(:err)
# type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero
# (Solid::Result::Contract::Error::UnexpectedType)
```
The _**mixin mode**_ is similar to `Solid::Result::Mixin`, but it also defines the expectations for the result's types and values.
```ruby
class Divide
include Solid::Result::Expectations.mixin(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_nonzero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
```
This mode also defines an `Result` constant to be used inside and outside the module.
> **PROTIP:**
> You can use the `Result` constant to mock the result's type and value in your tests. As they will have the exact expectations, your tests will check if the result clients are handling the result correctly.
Now that you know the two modes, let's understand how expectations can be beneficial and powerful for defining contracts.
⬆️ back to top
#### Type checking - Result Hooks
The `Solid::Result::Expectations` will check if the type of the result is valid. This checking will be performed in all methods that depend on the result’s type, such as `#success?`, `#failure?`, `#on`, `#on_type`, `#on_success`, `#on_failure`, and `#handle`.
##### `#success?` and `#failure?`
When checking whether a result is a success or failure, `Solid::Result::Expectations` will also verify if the result type is valid/expected. In case of an invalid type, an error will be raised.
**Success example:**
```ruby
result = Divide.new.call(10, 2)
result.success? # true
result.success?(:numbers) # false
result.success?(:division_completed) # true
result.success?(:ok)
# type :ok is not allowed. Allowed types: :numbers, :division_completed
# (Solid::Result::Contract::Error::UnexpectedType)
```
**Failure example:**
```ruby
result = Divide.new.call(10, '2')
result.failure? # true
result.failure?(:invalid_arg) # true
result.failure?(:division_by_zero) # false
result.failure?(:err)
# type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero
# (Solid::Result::Contract::Error::UnexpectedType)
```
*PS: The `Divide` implementation is [here](#standalone-versus-mixin-mode).*
⬆️ back to top
##### `#on` and `#on_type`
If you use `#on` or `#on_type` to execute a block, `Solid::Result::Expectations` will check whether the result type is valid/expected. Otherwise, an error will be raised.
```ruby
result = Divide.new.call(10, 2)
result
.on(:invalid_arg, :division_by_zero) { |msg| puts msg }
.on(:division_completed) { |number| puts "The result is #{number}" }
# The code above will print 'The result is 5'
result.on(:number) { |_| :this_type_does_not_exist }
# type :number is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero
# (Solid::Result::Contract::Error::UnexpectedType)
```
*PS: The `Divide` implementation is [here](#standalone-versus-mixin-mode).*
⬆️ back to top
##### `#on_success` and `#on_failure`
If you use `#on_success` or `#on_failure` to execute a block, `Solid::Result::Expectations` will check whether the result type is valid/expected. Otherwise, an error will be raised.
```ruby
result = Divide.new.call(10, '2')
result
.on_failure(:invalid_arg, :division_by_zero) { |msg| puts msg }
.on_success(:division_completed) { |number| puts "The result is #{number}" }
result
.on_success { |number| puts "The result is #{number}" }
.on_failure { |msg| puts msg }
# Both codes above will print 'arg2 must be numeric'
result.on_success(:ok) { |_| :this_type_does_not_exist }
# type :ok is not allowed. Allowed types: :numbers, :division_completed
# (Solid::Result::Contract::Error::UnexpectedType)
result.on_failure(:err) { |_| :this_type_does_not_exist }
# type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero
# (Solid::Result::Contract::Error::UnexpectedType)
```
*PS: The `Divide` implementation is [here](#standalone-versus-mixin-mode).*
⬆️ back to top
##### `#handle`
The `Solid::Result::Expectations` will also be applied on all the handlers defined by the `#handle` method/block.
```ruby
result = Divide.call(10, 2)
result.handle do |on|
on.type(:ok) { |_| :this_type_does_not_exist }
end
# type :ok is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero (Solid::Result::Contract::Error::UnexpectedType)
result.handle do |on|
on.success(:ok) { |_| :this_type_does_not_exist }
end
# type :ok is not allowed. Allowed types: :numbers, :division_completed (Solid::Result::Contract::Error::UnexpectedType)
result.handle do |on|
on.failure(:err) { |_| :this_type_does_not_exist }
end
# type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero (Solid::Result::Contract::Error::UnexpectedType)
```
*PS: The `Divide` implementation is [here](#standalone-versus-mixin-mode).*
⬆️ back to top
#### Type checking - Result Creation
The `Solid::Result::Expectations` will be used on the result creation `Success()` and `Failure()` methods. So, when the result type is valid/expected, the result will be created. Otherwise, an error will be raised.
This works for both modes (standalone and mixin).
##### Mixin mode
```ruby
module Divide
extend Solid::Result::Expectations.mixin(success: :ok, failure: :err)
def self.call(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
arg2.zero? and return Failure(:division_by_zero, 'arg2 must not be zero')
Success(:division_completed, arg1 / arg2)
end
end
Divide.call('4', 2)
# type :invalid_arg is not allowed. Allowed types: :err
# (Solid::Result::Contract::Error::UnexpectedType)
Divide.call(4, 2)
# type :division_completed is not allowed. Allowed types: :ok
# (Solid::Result::Contract::Error::UnexpectedType)
```
⬆️ back to top
##### Standalone mode
```ruby
module Divide
Result = Solid::Result::Expectations.new(success: :ok, failure: :err)
def self.call(arg1, arg2)
arg1.is_a?(Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
arg2.zero? and return Result::Failure(:division_by_zero, 'arg2 must not be zero')
Result::Success(:division_completed, arg1 / arg2)
end
end
Divide.call('4', 2)
# type :invalid_arg is not allowed. Allowed types: :err
# (Solid::Result::Contract::Error::UnexpectedType)
Divide.call(4, 2)
# type :division_completed is not allowed. Allowed types: :ok
# (Solid::Result::Contract::Error::UnexpectedType)
```
⬆️ back to top
#### Value checking - Result Creation
The `Result::Expectations` supports two types of validations. The first is the type checking only, and the second is the type and value checking.
To define expectations for your result's values, you must declare a Hash with the type as the key and the value as the value. A value validator is any object that responds to `#===` (case equality operator).
**Mixin mode:**
```ruby
module Divide
extend Solid::Result::Expectations.mixin(
success: {
numbers: ->(value) { value.is_a?(Array) && value.size == 2 && value.all?(Numeric) },
division_completed: Numeric
},
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def self.call(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
arg2.zero? and return Failure(:division_by_zero, 'arg2 must not be zero')
Success(:division_completed, arg1 / arg2)
end
end
```
**Standalone mode:**
```ruby
module Divide
Result = Solid::Result::Expectations.new(
success: {
numbers: ->(value) { value.is_a?(Array) && value.size == 2 && value.all?(Numeric) },
division_completed: Numeric
},
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def self.call(arg1, arg2)
arg1.is_a?(Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
arg2.zero? and return Result::Failure(:division_by_zero, 'arg2 must not be zero')
Result::Success(:division_completed, arg1 / arg2)
end
end
```
The value validation will only be performed through the methods `Success()` and `Failure()`.
⬆️ back to top
##### Success()
```ruby
Divide::Result::Success(:ok)
# type :ok is not allowed. Allowed types: :numbers, :division_completed (Solid::Result::Contract::Error::UnexpectedType)
Divide::Result::Success(:numbers, [1])
# value [1] is not allowed for :numbers type (Solid::Result::Contract::Error::UnexpectedValue)
Divide::Result::Success(:division_completed, '2')
# value "2" is not allowed for :division_completed type (Solid::Result::Contract::Error::UnexpectedValue)
```
##### Failure()
```ruby
Divide::Result::Failure(:err)
# type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero (Solid::Result::Contract::Error::UnexpectedType)
Divide::Result::Failure(:invalid_arg, :arg1_must_be_numeric)
# value :arg1_must_be_numeric is not allowed for :invalid_arg type (Solid::Result::Contract::Error::UnexpectedValue)
Divide::Result::Failure(:division_by_zero, msg: 'arg2 must not be zero')
# value {:msg=>"arg2 must not be zero"} is not allowed for :division_by_zero type (Solid::Result::Contract::Error::UnexpectedValue)
```
⬆️ back to top
##### Pattern Matching Support
The value checking has support for handling pattern-matching errors, and the cleanest way to do it is using the one-line pattern matching operators (`=>` since Ruby 3.0) and (`in` Ruby 2.7).
How does this operator work? They raise an error when the pattern does not match but returns nil when it matches.
Because of this, you will need to enable `nil` as a valid value checking. You can do it through the `Solid::Result.configuration` or by allowing it directly on the mixin config.
```ruby
module Divide
extend Solid::Result::Expectations.mixin(
config: {
pattern_matching: { nil_as_valid_value_checking: true }
},
success: {
division_completed: ->(value) { value => (Integer | Float) }
},
failure: { invalid_arg: String, division_by_zero: String }
)
def self.call(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
arg2.zero? and return Failure(:division_by_zero, 'arg2 must not be zero')
Success(:division_completed, String(arg1 / arg2))
end
end
Divide.call(10, 5)
# value "2" is not allowed for :division_completed type ("2": Float === "2" does not return true) (Solid::Result::Contract::Error::UnexpectedValue)
```
⬆️ back to top
#### `Solid::Result::Expectations.mixin` add-ons
The `Solid::Result::Expectations.mixin` also accepts the `config:` argument. It is a hash that can be used to define custom behaviors for the mixin.
**Continue**
It is similar to `Solid::Result.mixin(config: { addon: { continue: true } })`. The key difference is that the expectations will ignore the `Continue(value)`.
Based on this, use the `Success()` to produce a terminal result and `Continue()` to produce a result that will be used in the next step.
```ruby
class Divide
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_nonzero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
result = Divide.new.call(4, 2)
# => #
# The example below shows an error because the :ok type is not allowed.
# But look at the allowed types have only one type (:division_completed).
# This is because the :_continue_ type is ignored by the expectations.
#
result.success?(:ok)
# type :ok is not allowed. Allowed types: :division_completed (Solid::Result::Contract::Error::UnexpectedType)
```
⬆️ back to top
### `Solid::Output`
The `Solid::Output` is a `Solid::Result`, meaning it has all the features of the `Solid::Result`. The main difference is that it only accepts keyword arguments as a value, which applies to the `and_then`: The called methods must receive keyword arguments, and the dependency injection will be performed through keyword arguments.
As the input/output are hashes, the results of each `and_then` call will automatically accumulate. This is useful in operations chaining, as the result of the previous operations will be automatically available for the next one. Because of this behavior, the `Solid::Output` has the `#and_expose` method to expose only the desired keys from the accumulated result.
#### Defining successes and failures
As the `Solid::Result`, you can declare success and failures directly from `Solid::Output`.
```ruby
Solid::Output::Success(:ok, a: 1, b: 2)
#1, :b=>2}>
Solid::Output::Failure(:err, message: 'something went wrong')
#"something went wrong"}>
```
But different from `Solid::Result` that accepts any value, the `Solid::Output` only takes keyword arguments.
```ruby
Solid::Output::Success(:ok, [1, 2])
# wrong number of arguments (given 2, expected 1) (ArgumentError)
Solid::Output::Failure(:err, { message: 'something went wrong' })
# wrong number of arguments (given 2, expected 1) (ArgumentError)
#
# Use ** to convert a hash to keyword arguments
#
Solid::Output::Success(:ok, **{ message: 'hashes can be converted to keyword arguments' })
#"hashes can be converted to keyword arguments"}>
```
⬆️ back to top
#### Hash methods
The `Solid::Output` only accepts hashes as its values. Because of this, its instances have some Hash's methods to query/access the values. The available methods are:
- `#slice` to extract only the desired keys.
- `#[]`, `#dig`, `#fetch` to access the values.
- `#values_at` and `#fetch_values` to get the values of the desired keys.
```ruby
result = Solid::Output::Success(:ok, a: 1, b: 2, c: {d: 4})
result[:a] # 1
result.fetch(:a) # 1
result.dig(:c, :d) # 4
result.slice(:a, :b) # {:a=>1, :b=>2}
result.values_at(:a, :b) # [1, 2]
result.fetch_values(:a, :b) # [1, 2]
```
These methods are available for `Solid::Output::Success` and `Solid::Output::Failure` instances.
⬆️ back to top
#### `Solid::Output.mixin`
As in the `Solid::Result`, you can use the `Solid::Output.mixin` to add the `Success()` and `Failure()` methods to your classes/modules.
Let's see this feature and the data accumulation in action:
##### Class example (Instance Methods)
```ruby
require 'logger'
class Divide
include Solid::Output.mixin
def call(arg1, arg2, logger: ::Logger.new(STDOUT))
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero)
.and_then(:divide, logger: logger)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def validate_nonzero(number2:, **)
return Success(:ok) if number2.nonzero?
Failure(:err, message: 'arg2 must not be zero')
end
#
# The logger was injected via #and_then and keyword arguments
#
def divide(number1:, number2:, logger:)
result = number1 / number2
logger.info("The division result is #{result}")
Success(:ok, number: result)
end
end
Divide.new.call(10, 5)
# I, [2023-10-27T01:51:46.905004 #76915] INFO -- : The division result is 2
#2}>
Divide.new.call('10', 5)
#"arg1 must be numeric"}>
Divide.new.call(10, '5')
#"arg2 must be numeric"}>
Divide.new.call(10, 0)
#"arg2 must not be zero"}>
```
⬆️ back to top
##### `and_expose`
This allows you to expose only the desired keys from the accumulated result. It can be used with any `Solid::Output` object.
Let's add it to the previous example:
```ruby
class Divide
include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero)
.and_then(:divide)
.and_expose(:division_completed, [:number])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def validate_nonzero(number2:, **)
return Success(:ok) if number2.nonzero?
Failure(:err, message: 'arg2 must not be zero')
end
def divide(**input)
Success(:ok, number: input.values.reduce(:/), **input)
end
end
Divide.new.call(10, 5)
#2}>
```
As you can see, even with `divide` success exposing the division number with all the accumulated data (`**input`), the `#and_expose` could generate a new success with a new type and only with the desired keys.
Remove the `#and_expose` call to see the difference. This will be the outcome:
```ruby
Divide.new.call(10, 5)
#2, :number1=>10, :number2=>5}>
```
> PS: The `#and_expose` produces a terminal success by default. This means the next step will not be executed even if you call `#and_then` after `#and_expose`. To change this behavior, you can pass `terminal: false` to `#and_expose`.
⬆️ back to top
##### Module example (Singleton Methods)
`Solid::Output.mixin` can also produce singleton methods. Below is an example using a module (but it could be a class, too).
```ruby
module Divide
extend self, Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_nonzero)
.and_then(:divide)
.and_expose(:division_completed, [:number])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def validate_nonzero(number2:, **)
return Success(:ok) if number2.nonzero?
Failure(:err, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:ok, number: number1 / number2)
end
end
Divide.call(10, 5)
#2}>
Divide.call('10', 5)
#"arg1 must be numeric"}>
Divide.call(10, '5')
#"arg2 must be numeric"}>
Divide.call(10, 0)
#"arg2 must not be zero"}>
```
⬆️ back to top
#### `Solid::Output::Expectations`
The `Solid::Output::Expectations` is a `Solid::Result::Expectations` with the `Solid::Output` features.
This is an example using the mixin mode, but the standalone mode is also supported.
```ruby
class Divide
include Solid::Output::Expectations.mixin(
config: {
pattern_matching: { nil_as_valid_value_checking: true }
},
success: {
division_completed: ->(value) { value => { number: Numeric } }
},
failure: {
invalid_arg: ->(value) { value => { message: String } },
division_by_zero: ->(value) { value => { message: String } }
}
)
def call(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
arg2.zero? and return Failure(:division_by_zero, message: 'arg2 must not be zero')
Success(:division_completed, number: (arg1 / arg2))
end
end
Divide.new.call(10, 5)
#2}>
```
As in the `Solid::Result::Expectations.mixin`, the `Solid::Output::Expectations.mixin` will add a Result constant in the target class. It can generate success/failure results, which ensure the mixin expectations.
Let's see this using the previous example:
```ruby
Divide::Result::Success(:division_completed, number: 2)
#2}>
Divide::Result::Success(:division_completed, number: '2')
# value {:number=>"2"} is not allowed for :division_completed type ({:number=>"2"}: Numeric === "2" does not return true) (Solid::Result::Contract::Error::UnexpectedValue)
```
⬆️ back to top
#### Mixin add-ons
The `Solid::Output.mixin` and `Solid::Output::Expectations.mixin` also accepts the `config:` argument. And it works the same way as the `Solid::Result` mixins.
**given**
This addon is enabled by default. It will create the `Given(*value)` method. Use it to add a value to the result chain and invoke the next step (through `and_then`).
You can turn it off by passing `given: false` to the `config:` argument or using the `Solid::Result.configuration`.
The `Given()` addon for a Solid::Output can be called with one or more arguments. The arguments will be converted to a hash (`to_h`) and merged to define the first value of the result chain.
**continue**
The `Solid::Output.mixin(config: { addon: { continue: true } })` or `Solid::Output::Expectations.mixin(config: { addon: { continue: true } })` creates the `Continue(value)` method and change the `Success()` behavior to terminate the step chain.
So, if you want to advance to the next step, you must use `Continue(**value)` instead of `Success(type, **value)`. Otherwise, the step chain will be terminated.
Let's use a mix of `Solid::Output` features to see in action with this add-on:
```ruby
module Division
require 'logger'
extend self, Solid::Output::Expectations.mixin(
config: {
addon: { continue: true },
pattern_matching: { nil_as_valid_value_checking: true }
},
success: {
division_completed: ->(value) { value => { number: Numeric } }
},
failure: {
invalid_arg: ->(value) { value => { message: String } },
division_by_zero: ->(value) { value => { message: String } }
}
)
def call(arg1, arg2, logger: ::Logger.new(STDOUT))
Given(number1: arg1, number2: arg2)
.and_then(:require_numbers)
.and_then(:check_for_zeros)
.and_then(:divide, logger: logger)
.and_expose(:division_completed, [:number])
end
private
def require_numbers(number1:, number2:)
number1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
number2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue()
end
def check_for_zeros(number1:, number2:)
return Failure(:division_by_zero, message: 'arg2 must not be zero') if number2.zero?
return Success(:division_completed, number: 0) if number1.zero?
Continue()
end
def divide(number1:, number2:, logger:)
result = number1 / number2
logger.info("The division result is #{result}")
Continue(number: result)
end
end
Division.call(14, 2)
# I, [2023-10-27T02:01:05.812388 #77823] INFO -- : The division result is 7
#7}>
Division.call(0, 2)
##0}>
Division.call('14', 2)
#"arg1 must be numeric"}>
Division.call(14, '2')
#"arg2 must be numeric"}>
Division.call(14, 0)
#"arg2 must not be zero"}>
```
⬆️ back to top
## Pattern Matching
The `Solid::Result` and `Solid::Output` also provides support to pattern matching.
### `Solid::Result`
In the further examples, I will use the `Divide` lambda to exemplify its usage.
```ruby
Divide = lambda do |arg1, arg2|
arg1.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Solid::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Solid::Result::Success(:division_completed, arg1 / arg2)
end
```
#### `Array`/`Find` patterns
```ruby
case Divide.call(4, 2)
in Solid::Failure[:invalid_arg, msg] then puts msg
in Solid::Failure[:division_by_zero, msg] then puts msg
in Solid::Success[:division_completed, num] then puts num
end
# The code above will print: 2
case Divide.call(4, 0)
in Solid::Failure[:invalid_arg, msg] then puts msg
in Solid::Failure[:division_by_zero, msg] then puts msg
in Solid::Success[:division_completed, num] then puts num
end
# The code above will print: arg2 must not be zero
```
⬆️ back to top
#### `Hash` patterns
```ruby
case Divide.call(10, 2)
in Solid::Failure(type: :invalid_arg, value: msg) then puts msg
in Solid::Failure(type: :division_by_zero, value: msg) then puts msg
in Solid::Success(type: :division_completed, value: num) then puts num
end
# The code above will print: 5
case Divide.call('10', 2)
in Solid::Failure(type: :invalid_arg, value: msg) then puts msg
in Solid::Failure(type: :division_by_zero, value: msg) then puts msg
in Solid::Success(type: :division_completed, value: num) then puts num
end
# The code above will print: arg1 must be numeric
```
You can also use `Solid::Result::Success` and `Solid::Result::Failure` as patterns.
⬆️ back to top
### `Solid::Output`
In the further examples, I will use the `Divide` lambda to exemplify its usage.
```ruby
Divide = lambda do |arg1, arg2|
arg1.is_a?(::Numeric) or return Solid::Output::Failure(:invalid_arg, err: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Solid::Output::Failure(:invalid_arg, err: 'arg2 must be numeric')
return Solid::Output::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
Solid::Output::Success(:division_completed, num: arg1 / arg2)
end
```
#### `Array`/`Find` patterns
```ruby
case Divide.call(4, 2)
in Solid::Failure[:invalid_arg, {msg:}] then puts msg
in Solid::Failure[:division_by_zero, {msg:}] then puts msg
in Solid::Success[:division_completed, {num:}] then puts num
end
# The code above will print: 2
case Divide.call(4, 0)
in Solid::Failure[:invalid_arg, {msg:}] then puts msg
in Solid::Failure[:division_by_zero, {msg:}] then puts msg
in Solid::Success[:division_completed, {num:}] then puts num
end
# The code above will print: arg2 must not be zero
```
⬆️ back to top
#### `Hash` patterns
If you don't provide the keys :type and :value, the pattern will match the result value.
```ruby
case Divide.call(10, 2)
in Solid::Failure({msg:}) then puts msg
in Solid::Success({num:}) then puts num
end
```
```ruby
case Divide.call(10, 2)
in Solid::Failure(type: :invalid_arg, value: {msg:}) then puts msg
in Solid::Failure(type: :division_by_zero, value: {msg:}) then puts msg
in Solid::Success(type: :division_completed, value: {num:}) then puts num
end
# The code above will print: 5
case Divide.call('10', 2)
in Solid::Failure(type: :invalid_arg, value: {msg:}) then puts {msg:}
in Solid::Failure(type: :division_by_zero, value: {msg:}) then puts msg
in Solid::Success(type: :division_completed, value: {num:}) then puts num
end
# The code above will print: arg1 must be numeric
```
You can also use `Solid::Output::Success` and `Solid::Output::Failure` as patterns.
⬆️ back to top
### How to pattern match without the concept of success and failure
You can use the classes `Solid::Result` and `Solid::Output` as patterns, and the pattern matching will work without the concept of success and failure.
```ruby
case Divide.call(10, 2)
in Solid::Output(:invalid_arg, {msg:}) then puts msg
in Solid::Output(:division_by_zero, {msg:}) then puts msg
in Solid::Output(:division_completed, {num:}) then puts num
end
case Divide.call(10, 2)
in Solid::Result(:invalid_arg, msg) then puts msg
in Solid::Result(:division_by_zero, msg) then puts msg
in Solid::Result(:division_completed, num) then puts num
end
```
The `Solid::Result` will also work with the `Solid::Output`, but the opposite won't.
⬆️ back to top
## `Solid::Result.event_logs`
Use `Solid::Result.event_logs(&block)` to track all the results produced in the same or between different operations (it works with `Solid::Result` and `Solid::Output`). When there is a nesting of `event_logs` blocks, this mechanism will be able to correlate parent and child blocks and present the duration of all operations in milliseconds.
When you wrap the creation of the result with `Solid::Result.event_logs`, the final one will expose all the event log records through the `Solid::Result#event_logs` method.
```ruby
class Division
include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Solid::Result.event_logs(name: 'Division', desc: 'divide two numbers') do
Given([arg1, arg2])
.and_then(:require_numbers)
.and_then(:check_for_zeros)
.and_then(:divide)
end
end
private
ValidNumber = ->(arg) { arg.is_a?(Numeric) && (!arg.respond_to?(:finite?) || arg.finite?) }
def require_numbers((arg1, arg2))
ValidNumber[arg1] or return Failure(:invalid_arg, 'arg1 must be a valid number')
ValidNumber[arg2] or return Failure(:invalid_arg, 'arg2 must be a valid number')
Continue([arg1, arg2])
end
def check_for_zeros(numbers)
num1, num2 = numbers
return Failure(:division_by_zero, 'num2 cannot be zero') if num2.zero?
num1.zero? ? Success(:division_completed, 0) : Continue(numbers)
end
def divide((num1, num2))
Success(:division_completed, num1 / num2)
end
end
module SumDivisionsByTwo
extend self, Solid::Result.mixin
def call(*numbers)
Solid::Result.event_logs(name: 'SumDivisionsByTwo') do
divisions = numbers.map { |number| Division.new.call(number, 2) }
if divisions.any?(&:failure?)
Failure(:errors, divisions.select(&:failure?).map(&:value))
else
Success(:sum, divisions.sum(&:value))
end
end
end
end
```
Let's see the result of the `SumDivisionsByTwo` call:
```ruby
result = SumDivisionsByTwo.call(20, 10)
# => #
result.event_logs
{
:version => 1,
:metadata => {
:duration => 0, # milliseconds
:trace_id => nil, # can be set through configuration
:ids => {
:tree => [0, [[1, []], [2, []]]],
:matrix => { 0 => [0, 0], 1 => [1, 1], 2 => [2, 1]},
:level_parent => { 0 => [0, 0], 1 => [1, 0], 2 => [1, 0]}
}
},
:records=> [
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
:result => {:kind=>:success, :type=>:_given_, :value=>[20, 2], :source=>},
:and_then => {},
:time => 2024-01-26 02:53:11.310346 UTC
},
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
:result => {:kind=>:success, :type=>:_continue_, :value=>[20, 2], :source=>},
:and_then => {:type=>:method, :arg=>nil, :method_name=>:require_numbers},
:time => 2024-01-26 02:53:11.310392 UTC
},
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
:result => {:kind=>:success, :type=>:_continue_, :value=>[20, 2], :source=>},
:and_then => {:type=>:method, :arg=>nil, :method_name=>:check_for_zeros},
:time=>2024-01-26 02:53:11.310403 UTC
},
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>1, :name=>"Division", :desc=>"divide two numbers"},
:result => {:kind=>:success, :type=>:division_completed, :value=>10, :source=>},
:and_then => {:type=>:method, :arg=>nil, :method_name=>:divide},
:time => 2024-01-26 02:53:11.310409 UTC
},
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
:result => {:kind=>:success, :type=>:_given_, :value=>[10, 2], :source=>},
:and_then => {},
:time => 2024-01-26 02:53:11.310424 UTC
},
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
:result => {:kind=>:success, :type=>:_continue_, :value=>[10, 2], :source=>},
:and_then => {:type=>:method, :arg=>nil, :method_name=>:require_numbers},
:time => 2024-01-26 02:53:11.310428 UTC
},
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
:result => {:kind=>:success, :type=>:_continue_, :value=>[10, 2], :source=>},
:and_then => {:type=>:method, :arg=>nil, :method_name=>:check_for_zeros},
:time => 2024-01-26 02:53:11.310431 UTC
},
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>2, :name=>"Division", :desc=>"divide two numbers"},
:result => {:kind=>:success, :type=>:division_completed, :value=>5, :source=>},
:and_then => {:type=>:method, :arg=>nil, :method_name=>:divide},
:time => 2024-01-26 02:53:11.310434 UTC
},
{
:root => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:parent => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:current => {:id=>0, :name=>"SumDivisionsByTwo", :desc=>nil},
:result => {:kind=>:success, :type=>:sum, :value=>15, :source=>SumDivisionsByTwo},
:and_then => {},
:time => 2024-01-26 02:53:11.310444 UTC
}
]
}
```
⬆️ back to top
### `metadata: {ids:}`
The `:ids` metadata property is a hash with three properties:
- `:tree`, a graph/tree representation of the id of each `event_logs` block.
- `:level_parent`, a hash with the level (depth) of each block and its parent id.
- `:matrix`, a matrix representation of the event logs ids. It is a simplification of the `:tree` property.
Use these data structures to build your own visualization.
> Check out [Event Logs Listener example](examples/single_listener/lib/single_event_logs_listener.rb) to see how a listener can be used to build a STDOUT visualization, using these properties.
```ruby
# tree:
# A graph representation (array of arrays) of the each event logs block id.
#
0 # [0, [
|- 1 # [1, [[2, []]]],
| |- 2 # [3, []],
|- 3 # [4, [
|- 4 # [5, []],
| |- 5 # [6, [[7, []]]]
| |- 6 # ]],
| |- 7 # [8, []]
|- 8 # ]]
# level_parent:
# The event logs ids are the keys, and the level (depth) and parent id the values.
# {
0 # 0 => [0, 0],
|- 1 # 1 => [1, 0],
| |- 2 # 2 => [2, 1],
|- 3 # 3 => [1, 0],
|- 4 # 4 => [1, 0],
| |- 5 # 5 => [2, 4],
| |- 6 # 6 => [2, 4],
| |- 7 # 7 => [3, 6],
|- 8 # 8 => [1, 0]
# }
# matrix:
# The rows are the direct blocks from the root block,
# and the columns are the nested blocks from the direct ones.
# {
0 | 1 | 2 | 3 | 4 # 0 => [0, 0],
- | - | - | - | - # 1 => [1, 1],
0 | | | | # 2 => [1, 2],
1 | 1 | 2 | | # 3 => [2, 1],
2 | 3 | | | # 4 => [3, 1],
3 | 4 | 5 | 6 | 7 # 5 => [3, 2],
4 | 8 | | | # 6 => [3, 3],
# 7 => [3, 4],
# 8 => [4, 1]
# }
```
⬆️ back to top
### Configuration
#### Turning on/off
You can use `Solid::Result.config.feature.disable!(event_logs)` and `Solid::Result.config.feature.enable!(event_logs)` to turn on/off the `Solid::Result.event_logs` feature.
```ruby
Solid::Result.configuration do |config|
config.feature.disable!(event_logs)
end
result = SumDivisionsByTwo.call(20, 10)
# => #
result.event_logs
{
:version=>1,
:records=>[],
:metadata=>{
:duration=>0,
:ids=>{:tree=>[], :matrix=>{}, :level_parent=>{}}, :trace_id=>nil
}
}
```
⬆️ back to top
#### Setting a `trace_id` fetcher
You can define a lambda (arity 0) to fetch the trace_id. This lambda will be called before the first event logs block and will be used to set the `:trace_id` in the `:metadata` property.
Use to correlate different or the same operation (executed multiple times).
```ruby
Solid::Result.config.event_logs.trace_id = -> { Thread.current[:solid_result_event_logs_trace_id] }
```
⬆️ back to top
#### Setting a `listener`
You can define a listener to be called during the event logs tracking (check out [this example](examples/single_listener/lib/single_event_logs_listener.rb)). It must be a class that includes `Solid::Result::EventLogs::Listener`.
Use it to build your additional logic on top of the tracking. Examples:
- Log the event logs.
- Perform the tracing.
- Instrument the event logs (measure/report).
- Build a visualization (Diagrams, using the `records:` + `metadata: {ids:}` properties).
After implementing your listener, you can set it to the `Solid::Result.config.event_logs.listener=`:
```ruby
Solid::Result.config.event_logs.listener = MyEventLogsListener
```
See the example below to understand how to implement one:
```ruby
class MyEventLogsListener
include Solid::Result::EventLogs::Listener
# A listener will be initialized before the first event logs block, and it is discarded after the last one.
def initialize
end
# This method will be called before each event logs block.
# The parent block will be called first in the case of nested ones.
#
# @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
def on_start(scope:)
end
# This method will wrap all the event logs in the same block.
# It can be used to perform an instrumentation (measure/report).
#
# @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
def around_event_logs(scope:)
yield
end
# This method will wrap each and_then call.
# It can be used to perform an instrumentation of the and_then calls.
#
# @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
# @param and_then:
# {:type=>:block, :arg=>:some_injected_value}
# {:type=>:method, :arg=>:some_injected_value, :method_name=>:some_method_name}
def around_and_then(scope:, and_then:)
yield
end
# This method will be called after each result recording/tracking.
#
# @param record:
# {
# :root => {:id=>0, :name=>"RootOperation", :desc=>nil},
# :parent => {:id=>0, :name=>"RootOperation", :desc=>nil},
# :current => {:id=>1, :name=>"SomeOperation", :desc=>nil},
# :result => {:kind=>:success, :type=>:_continue_, :value=>{some: :thing}, :source=>},
# :and_then => {:type=>:method, :arg=>nil, :method_name=>:some_method},
# :time => 2024-01-26 02:53:11.310431 UTC
# }
def on_record(record:)
end
# This method will be called at the end of the event logs tracking.
#
# @param event_logs:
# {
# :version => 1,
# :metadata => {
# :duration => 0,
# :trace_id => nil,
# :ids => {
# :tree => [0, [[1, []], [2, []]]],
# :matrix => { 0 => [0, 0], 1 => [1, 1], 2 => [2, 1]},
# :level_parent => { 0 => [0, 0], 1 => [1, 0], 2 => [1, 0]}
# }
# },
# :records => [
# # ...
# ]
# }
def on_finish(event_logs:)
end
# This method will be called when an exception is raised during the event logs tracking.
#
# @param exception: Exception
# @param event_logs: Hash
def before_interruption(exception:, event_logs:)
end
end
```
⬆️ back to top
#### Setting multiple `listeners`
You can use `Solid::Result::EventLogs::Listeners[]` to creates a listener of listeners (check out [this example](examples/multiple_listeners/Rakefile)), which will be called in the order they were added.
**Attention:** It only allows one listener to handle `around_and_then` and another `around_event_logs` records.
> The example below defines different listeners to handle `around_and_then` and `around_event_logs,` but it is also possible to define a listener to handle both.
```ruby
class AroundAndThenListener
include Solid::Result::EventLogs::Listener
# It must be a static/singleton method.
def self.around_and_then?
true
end
def around_and_then(scope:, and_then:)
#...
end
end
class AroundEventLogsListener
include Solid::Result::EventLogs::Listener
# It must be a static/singleton method.
def self.around_event_logs?
true
end
def around_event_logs(scope:)
#...
end
end
class MyEventLogsListener
include Solid::Result::EventLogs::Listener
end
```
How to use it:
```ruby
# The listeners will be called in the order they were added.
Solid::Result.config.event_logs.listener = Solid::Result::EventLogs::Listeners[
MyEventLogsListener,
AroundAndThenListener,
AroundEventLogsListener
]
```
> Check out [this example](examples/multiple_listeners) to see a listener to print the event logs and another to store them in the database.
⬆️ back to top
## `Solid::Result.configuration`
The `Solid::Result.configuration` allows you to configure default behaviors for `Solid::Result` and `Solid::Output` through a configuration block. After using it, the configuration is frozen, ensuring the expected behaviors for your application.
> Note: You can use `Solid::Result.configuration(freeze: false) {}` to avoid the freezing. This can be useful in tests. Please be sure to use it with caution.
```ruby
Solid::Result.configuration do |config|
config.addon.enable!(:given, :continue)
config.constant_alias.enable!('Result', 'Solid::Output')
config.pattern_matching.disable!(:nil_as_valid_value_checking)
# config.feature.disable!(:expectations) if ::Rails.env.production?
end
```
Use `disable!` to disable a feature and `enable!` to enable it.
Let's see what each configuration in the example above does:
### `config.addon.enable!(:given, :continue)`
This configuration enables the `Continue()` method for `Solid::Result.mixin`, `Solid::Output.mixin`, `Solid::Result::Expectation.mixin`, and `Solid::Output::Expectation.mixin`. Link to documentations: [(1)](#add-ons) [(2)](#mixin-add-ons).
It is also enabling the `Given()` which is already enabled by default. Link to documentation: [(1)](#add-ons) [(2)](#mixin-add-ons).
### `config.constant_alias.enable!('Result', 'Solid::Output')`
This configuration make `Result` a constant alias for `Solid::Result`, and `Solid::Output` a constant alias for `Solid::Output`.
Link to documentations:
- [Result alias](#solidresult-versus-result)
### `config.pattern_matching.disable!(:nil_as_valid_value_checking)`
This configuration disables the `nil_as_valid_value_checking` for `Solid::Result` and `Solid::Output`. Link to [documentation](#pattern-matching-support).
### `config.feature.disable!(:expectations)`
This configuration turns off the expectations for `Solid::Result` and `Solid::Output`. The expectations are helpful in development and test environments, but they can be disabled in production environments for performance gain.
PS: I'm using `::Rails.env.production?` to check the environment, but you can use any logic you want.
⬆️ back to top
### `Solid::Result.config`
The `Solid::Result.config` allows you to access the current configuration.
#### **Solid::Result.config.addon**
```ruby
Solid::Result.config.addon.enabled?(:continue)
Solid::Result.config.addon.enabled?(:given)
Solid::Result.config.addon.options
# {
# :continue=>{
# :enabled=>false,
# :affects=>[
# "Solid::Result.mixin",
# "Solid::Output.mixin",
# "Solid::Result::Expectations.mixin",
# "Solid::Output::Expectations.mixin"
# ]
# },
# :given=>{
# :enabled=>true,
# :affects=>[
# "Solid::Result.mixin",
# "Solid::Output.mixin",
# "Solid::Result::Expectations.mixin",
# "Solid::Output::Expectations.mixin"
# ]
# }
# }
```
#### **Solid::Result.config.constant_alias**
```ruby
Solid::Result.config.constant_alias.enabled?('Result')
Solid::Result.config.constant_alias.options
# {
# "Result"=>{:enabled=>false, :affects=>["Object"]}
# }
```
#### **Solid::Result.config.pattern_matching**
```ruby
Solid::Result.config.pattern_matching.enabled?(:nil_as_valid_value_checking)
Solid::Result.config.pattern_matching.options
# {
# :nil_as_valid_value_checking=>{
# :enabled=>false,
# :affects=>[
# "Solid::Result::Expectations,
# "Solid::Output::Expectations"
# ]
# }
# }
```
#### **Solid::Result.config.feature**
```ruby
Solid::Result.config.feature.enabled?(:expectations)
Solid::Result.config.feature.options
# {
# :expectations=>{
# :enabled=>true,
# :affects=>[
# "Solid::Result::Expectations,
# "Solid::Output::Expectations"
# ]
# },
# event_logs=>{
# :enabled=>true,
# :affects=>[
# "Solid::Result",
# "Solid::Output"
# ]
# },
# :and_then!=>{
# :enabled=>false,
# :affects=>[
# "Solid::Result",
# "Solid::Output"
# ]
# },
# }
```
⬆️ back to top
## `Solid::Result#and_then!`
In the Ruby ecosystem, several gems facilitate operation composition using classes and modules. Two notable examples are the `interactor` gem and the `u-case` gem.
**`interactor` gem example**
```ruby
class PlaceOrder
include Interactor::Organizer
organize CreateOrder,
PayOrder,
SendOrderConfirmation,
NotifyAdmins
end
```
**`u-case` gem example**
```ruby
class PlaceOrder < Micro::Case
flow CreateOrder, PayOrder, SendOrderConfirmation, NotifyAdmins
end
# Alternative approach
class PlaceOrder < Micro::Case
def call!
call(CreateOrder)
.then(PayOrder)
.then(SendOrderConfirmation)
.then(NotifyAdmins)
end
end
```
To facilitate migration for users accustomed to the above approaches, `solid-result` includes the `Solid::Result#and_then!`/`Solid::Output#and_then!` methods, which will invoke the method `call` of the given operation and expect it to return a `Solid::Result`/`Solid::Output` object.
```ruby
Solid::Result.configure do |config|
config.feature.enable!(:and_then!)
end
class PlaceOrder
include Solid::Output.mixin
def call(**input)
Given(input)
.and_then!(CreateOrder.new)
.and_then!(PayOrder.new)
.and_then!(SendOrderConfirmation.new)
.and_then!(NotifyAdmins.new)
end
end
```
⬆️ back to top
#### Dependency Injection
Like `#and_then`, `#and_then!` also supports an additional argument for dependency injection.
**In Solid::Result**
```ruby
class PlaceOrder
include Solid::Result.mixin
def call(input, logger:)
Given(input)
.and_then!(CreateOrder.new, logger)
# Further method chaining...
end
end
```
**In Solid::Output**
```ruby
class PlaceOrder
include Solid::Output.mixin
def call(logger:, **input)
Given(input)
.and_then!(CreateOrder.new, logger:)
# Further method chaining...
end
end
```
⬆️ back to top
#### Configuration
```ruby
Solid::Result.configure do |config|
config.feature.enable!(:and_then!)
config.and_then!.default_method_name_to_call = :perform
end
```
**Explanation:**
- `enable!(:and_then!)`: Activates the `and_then!` feature.
- `default_method_name_to_call`: Sets a default method other than `:call` for `and_then!`.
⬆️ back to top
#### Analysis: Why is `and_then!` an Anti-pattern?
The `and_then!` approach, despite its brevity, introduces several issues:
- **Lack of Clarity:** The input/output relationship between the steps is not apparent.
- **Steps Coupling:** Each operation becomes interdependent (high coupling), complicating implementation and compromising the reusability of these operations.
We recommend cautious use of `#and_then!`. Due to these issues, it is turned off by default and considered an antipattern.
It should be a temporary solution, primarily for assisting in migration from another to gem to `solid-result`.
⬆️ back to top
#### `#and_then` versus `#and_then!`
The main difference between the `#and_then` and `#and_then!` is that the latter does not check the result source. However, as a drawback, the result source will change.
Attention: to ensure the correct behavior, do not mix `#and_then` and `#and_then!` in the same result chain.
⬆️ back to top
#### Analysis: Why is `#and_then` the antidote/standard?
The `Solid::Result#and_then`/`Solid::Output#and_then` methods diverge from the above approach by requiring explicit invocation and mapping of the outcomes at each process step. This approach has the following advantages:
- **Clarity:** The input/output relationship between the steps is apparent and highly understandable.
- **Steps uncoupling:** Each operation becomes independent (low coupling). You can even map a failure result to a success (and vice versa).
See this example to understand what your code should look like:
```ruby
class PlaceOrder
include Solid::Output.mixin(config: { addon: { continue: true } })
def call(**input)
Given(input)
.and_then(:create_order)
.and_then(:pay_order)
.and_then(:send_order_confirmation)
.and_then(:notify_admins)
.and_expose(:order_placed, %i[order])
end
private
def create_order(customer:, products:)
CreateOrder.new.call(customer:, products:).handle do |on|
on.success { |output| Continue(order: output[:order]) }
on.failure { |error| Failure(:order_creation_failed, error:) }
end
end
def pay_order(customer:, order:, payment_method:, **)
PayOrder.new.call(customer:, payment_method:, order:).handle do |on|
on.success { |output| Continue(payment: output[:payment]) }
on.failure { |error| Failure(:order_payment_failed, error:) }
end
end
def send_order_confirmation(customer:, order:, payment:, **)
SendOrderConfirmation.new.call(customer:, order:, payment:).handle do |on|
on.success { Continue() }
on.failure { |error| Failure(:order_confirmation_failed, error:) }
end
end
def notify_admins(customer:, order:, payment:, **)
NotifyAdmins.new.call(customer:, order:, payment:)
Continue()
end
end
```
⬆️ back to top
## About
[Rodrigo Serradura](https://github.com/serradura) created this project. He is the Solid Process creator and has already made similar gems like the [u-case](https://github.com/serradura/u-case) and [kind](https://github.com/serradura/kind/blob/main/lib/kind/result.rb). This gem can be used independently, but it also contains essential features that facilitate the adoption of Solid Process (the method) in code.
⬆️ back to top
## Development
After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
⬆️ back to top
## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/solid-process/solid-result. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/solid-process/solid-result/blob/master/CODE_OF_CONDUCT.md).
⬆️ back to top
## License
The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
⬆️ back to top
## Code of Conduct
Everyone interacting in the Solid::Result project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/solid-process/solid-result/blob/master/CODE_OF_CONDUCT.md).
solid-result-2.0.0/Rakefile 0000664 0000000 0000000 00000001065 14606620746 0015621 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'bundler/gem_tasks'
require 'rake/testtask'
Rake::TestTask.new(:test) do |t|
t.libs += %w[lib test]
t.test_files = FileList.new('test/**/*_test.rb')
end
Rake::TestTask.new(:test_configuration) do |t|
t.libs += %w[lib test]
t.test_files = FileList.new('test/**/configuration_test.rb')
end
Rake::TestTask.new(:test_event_logs_duration) do |t|
t.libs += %w[lib test]
t.test_files = FileList.new('test/**/duration_test.rb')
end
require 'rubocop/rake_task'
RuboCop::RakeTask.new
task default: %i[test rubocop]
solid-result-2.0.0/Steepfile 0000664 0000000 0000000 00000001765 14606620746 0016026 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
D = Steep::Diagnostic
target :lib do
signature 'sig'
check 'lib' # Directory name
# check 'Gemfile' # File name
# check 'app/models/**/*.rb' # Glob
# ignore 'lib/templates/*.rb'
# library 'singleton' # Standard libraries
# library 'strong_json' # Gems
# configure_code_diagnostics(D::Ruby.default) # `default` diagnostics setting (applies by default)
# configure_code_diagnostics(D::Ruby.strict) # `strict` diagnostics setting
# configure_code_diagnostics(D::Ruby.lenient) # `lenient` diagnostics setting
# configure_code_diagnostics(D::Ruby.silent) # `silent` diagnostics setting
configure_code_diagnostics do |hash| # You can setup everything yourself
hash[D::Ruby::NoMethod] = :information
end
end
# target :test do
# signature 'sig', 'sig-private'
#
# check 'test'
#
# # library 'pathname' # Standard libraries
# end
solid-result-2.0.0/bin/ 0000775 0000000 0000000 00000000000 14606620746 0014722 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/bin/console 0000775 0000000 0000000 00000000436 14606620746 0016315 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
# frozen_string_literal: true
require 'bundler/setup'
require 'solid/result'
# You can add fixtures and/or initialization code here to make experimenting
# with your gem easier. You can also use a different console, if you like.
require 'irb'
IRB.start(__FILE__)
solid-result-2.0.0/bin/setup 0000775 0000000 0000000 00000000203 14606620746 0016003 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'
set -vx
bundle install
# Do any other automated setup that you need to do here
solid-result-2.0.0/examples/ 0000775 0000000 0000000 00000000000 14606620746 0015770 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/ 0000775 0000000 0000000 00000000000 14606620746 0021713 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/Rakefile 0000664 0000000 0000000 00000002464 14606620746 0023366 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
if RUBY_VERSION <= '3.1'
puts 'This example requires Ruby 3.1 or higher.'
exit! 1
end
# Usage:
#
# rake DISABLE_EVENT_LOGS=t
# rake DISABLE_LISTENER=t
#
# rake HIDE_GIVEN_AND_CONTINUE=t
#
# rake BREAK_ACCOUNT_CREATION=t
# rake BREAK_USER_CREATION=t
# rake BREAK_USER_TOKEN_CREATION=t
#
# rake BREAK_ACCOUNT_CREATION=t HIDE_GIVEN_AND_CONTINUE=t
task default: %i[solid_result_event_logs]
desc 'creates an account and an owner user through Solid::Result'
task :solid_result_event_logs do
require_relative 'config'
Solid::Result.configuration do |config|
config.feature.disable!(:event_logs) if ENV['DISABLE_EVENT_LOGS']
unless ENV['DISABLE_LISTENER']
config.event_logs.listener = Solid::Result::EventLogs::Listeners[
EventLogsListener::Stdout,
Solid::Result::EventLogsRecord::Listener
]
end
end
result = nil
bench = Benchmark.measure do
result = Account::OwnerCreation.new.call(
owner: {
name: "\tJohn Doe \n",
email: ' JOHN.doe@email.com',
password: '123123123',
password_confirmation: '123123123'
}
)
rescue RuntimeBreaker::Interruption => e
nil
end
puts "\nSolid::Result::EventLogsRecord.count: #{Solid::Result::EventLogsRecord.count}"
puts "\nBenchmark: #{bench}"
end
solid-result-2.0.0/examples/multiple_listeners/app/ 0000775 0000000 0000000 00000000000 14606620746 0022473 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/app/models/ 0000775 0000000 0000000 00000000000 14606620746 0023756 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/app/models/account.rb 0000664 0000000 0000000 00000000720 14606620746 0025736 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account < ActiveRecord::Base
has_many :memberships, inverse_of: :account, dependent: :destroy, class_name: '::Account::Member'
has_many :users, through: :memberships, inverse_of: :accounts
where_ownership = -> { where(account_members: {role: :owner}) }
has_one :ownership, where_ownership, dependent: nil, inverse_of: :account, class_name: '::Account::Member'
has_one :owner, through: :ownership, source: :user
end
solid-result-2.0.0/examples/multiple_listeners/app/models/account/ 0000775 0000000 0000000 00000000000 14606620746 0025412 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/app/models/account/member.rb 0000664 0000000 0000000 00000000407 14606620746 0027207 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account::Member < ActiveRecord::Base
self.table_name = 'account_members'
enum role: { owner: 0, admin: 1, contributor: 2 }
belongs_to :user, inverse_of: :memberships
belongs_to :account, inverse_of: :memberships
end
solid-result-2.0.0/examples/multiple_listeners/app/models/account/owner_creation.rb 0000664 0000000 0000000 00000003433 14606620746 0030760 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account
class OwnerCreation
include Solid::Output.mixin
include Solid::Result::RollbackOnFailure
def call(**input)
Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
.then { |result|
rollback_on_failure {
result
.and_then(:create_owner)
.and_then(:create_account)
.and_then(:link_owner_to_account)
}
}.and_expose(:account_owner_created, %i[user account])
end
end
private
def normalize_input(**options)
uuid = String(options.fetch(:uuid) { ::SecureRandom.uuid }).strip.downcase
Continue(uuid:)
end
def validate_input(uuid:, owner:)
err = ::Hash.new { |hash, key| hash[key] = [] }
err[:uuid] << 'must be an UUID' unless uuid.match?(/\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i)
err[:owner] << 'must be a Hash' unless owner.is_a?(::Hash)
err.empty? ? Continue() : Failure(:invalid_input, **err)
end
def create_owner(owner:, **)
::User::Creation.new.call(**owner).handle do |on|
on.success { |output| Continue(user: { record: output[:user], token: output[:token] }) }
on.failure { |output| Failure(:invalid_owner, **output) }
end
end
def create_account(uuid:, **)
::RuntimeBreaker.try_to_interrupt(env: 'BREAK_ACCOUNT_CREATION')
account = ::Account.create(uuid:)
account.persisted? ? Continue(account:) : Failure(:invalid_record, **account.errors.messages)
end
def link_owner_to_account(account:, user:, **)
Member.create!(account:, user: user.fetch(:record), role: :owner)
Continue()
end
end
end
solid-result-2.0.0/examples/multiple_listeners/app/models/user.rb 0000664 0000000 0000000 00000001056 14606620746 0025263 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User < ActiveRecord::Base
has_secure_password
has_many :memberships, inverse_of: :user, dependent: :destroy, class_name: '::Account::Member'
has_many :accounts, through: :memberships, inverse_of: :users
where_ownership = -> { where(account_members: { role: :owner }) }
has_one :ownership, where_ownership, inverse_of: :user, class_name: '::Account::Member'
has_one :account, through: :ownership, inverse_of: :owner
has_one :token, inverse_of: :user, dependent: :destroy, class_name: '::User::Token'
end
solid-result-2.0.0/examples/multiple_listeners/app/models/user/ 0000775 0000000 0000000 00000000000 14606620746 0024734 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/app/models/user/creation.rb 0000664 0000000 0000000 00000004244 14606620746 0027071 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User
class Creation
include Solid::Output.mixin
include Solid::Result::RollbackOnFailure
def call(**input)
Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
.and_then(:validate_email_uniqueness)
.then { |result|
rollback_on_failure {
result
.and_then(:create_user)
.and_then(:create_user_token)
}
}
.and_expose(:user_created, %i[user token])
end
end
private
def normalize_input(name:, email:, **options)
name = String(name).strip.gsub(/\s+/, ' ')
email = String(email).strip.downcase
uuid = String(options.fetch(:uuid) { ::SecureRandom.uuid }).strip.downcase
Continue(uuid:, name:, email:)
end
def validate_input(uuid:, name:, email:, password:, password_confirmation:)
err = ::Hash.new { |hash, key| hash[key] = [] }
err[:uuid] << 'must be an UUID' unless uuid.match?(/\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i)
err[:name] << 'must be present' if name.blank?
err[:email] << 'must be email' unless email.match?(::URI::MailTo::EMAIL_REGEXP)
err[:password] << 'must be present' if password.blank?
err[:password_confirmation] << 'must be present' if password_confirmation.blank?
err.empty? ? Continue() : Failure(:invalid_input, **err)
end
def validate_email_uniqueness(email:, **)
::User.exists?(email:) ? Failure(:email_already_taken) : Continue()
end
def create_user(uuid:, name:, email:, password:, password_confirmation:)
::RuntimeBreaker.try_to_interrupt(env: 'BREAK_USER_CREATION')
user = ::User.create(uuid:, name:, email:, password:, password_confirmation:)
user.persisted? ? Continue(user:) : Failure(:invalid_record, **user.errors.messages)
end
def create_user_token(user:, **)
Token::Creation.new.call(user: user).handle do |on|
on.success { |output| Continue(token: output[:token]) }
on.failure { raise 'Token creation failed' }
end
end
end
end
solid-result-2.0.0/examples/multiple_listeners/app/models/user/token.rb 0000664 0000000 0000000 00000000224 14606620746 0026377 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token < ActiveRecord::Base
self.table_name = 'user_tokens'
belongs_to :user, inverse_of: :token
end
solid-result-2.0.0/examples/multiple_listeners/app/models/user/token/ 0000775 0000000 0000000 00000000000 14606620746 0026054 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/app/models/user/token/creation.rb 0000664 0000000 0000000 00000003011 14606620746 0030200 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token
class Creation
include Solid::Output.mixin
def call(**input)
Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
.and_then(:validate_token_existence)
.and_then(:create_token)
.and_expose(:token_created, %i[token])
end
end
private
def normalize_input(**options)
Continue(executed_at: options.fetch(:executed_at) { ::Time.current })
end
def validate_input(user:, executed_at:)
err = ::Hash.new { |hash, key| hash[key] = [] }
err[:user] << 'must be a User' unless user.is_a?(::User)
err[:user] << 'must be persisted' unless user.try(:persisted?)
err[:executed_at] << 'must be a time' unless executed_at.is_a?(::Time)
err.empty? ? Continue() : Failure(:invalid_user, **err)
end
def validate_token_existence(user:, **)
user.token.nil? ? Continue() : Failure(:token_already_exists)
end
def create_token(user:, executed_at:, **)
::RuntimeBreaker.try_to_interrupt(env: 'BREAK_USER_TOKEN_CREATION')
token = user.create_token(
access_token: ::SecureRandom.hex(24),
refresh_token: ::SecureRandom.hex(24),
access_token_expires_at: executed_at + 15.days,
refresh_token_expires_at: executed_at + 30.days
)
token.persisted? ? Continue(token:) : Failure(:token_creation_failed, **token.errors.messages)
end
end
end
solid-result-2.0.0/examples/multiple_listeners/config.rb 0000664 0000000 0000000 00000001166 14606620746 0023511 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'bundler/inline'
$LOAD_PATH.unshift(__dir__)
require_relative 'config/boot'
require_relative 'config/initializers/solid_result'
require 'db/setup'
require 'lib/solid/result/rollback_on_failure'
require 'lib/solid/result/event_logs_record'
require 'lib/runtime_breaker'
module EventLogsListener
require 'lib/event_logs_listener/stdout'
end
require 'app/models/account'
require 'app/models/account/member'
require 'app/models/user'
require 'app/models/user/token'
require 'app/models/account/owner_creation'
require 'app/models/user/token/creation'
require 'app/models/user/creation'
solid-result-2.0.0/examples/multiple_listeners/config/ 0000775 0000000 0000000 00000000000 14606620746 0023160 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/config/boot.rb 0000664 0000000 0000000 00000000504 14606620746 0024447 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'bundler/inline'
$LOAD_PATH.unshift(__dir__)
gemfile do
source 'https://rubygems.org'
gem 'sqlite3', '~> 1.7'
gem 'bcrypt', '~> 3.1.20'
gem 'activerecord', '~> 7.1', '>= 7.1.3', require: 'active_record'
gem 'solid-result', path: '../../'
end
require 'active_support/all'
solid-result-2.0.0/examples/multiple_listeners/config/initializers/ 0000775 0000000 0000000 00000000000 14606620746 0025666 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/config/initializers/solid_result.rb 0000664 0000000 0000000 00000000362 14606620746 0030724 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
Solid::Result.config.then do |config|
config.addon.enable!(:continue)
config.pattern_matching.disable!(:nil_as_valid_value_checking)
# config.feature.disable!(:expectations) if Rails.env.production?
end
solid-result-2.0.0/examples/multiple_listeners/db/ 0000775 0000000 0000000 00000000000 14606620746 0022300 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/db/setup.rb 0000664 0000000 0000000 00000003207 14606620746 0023767 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'active_support/all'
ActiveRecord::Base.establish_connection(
host: 'localhost',
adapter: 'sqlite3',
database: ':memory:'
)
ActiveRecord::Schema.define do
suppress_messages do
create_table :solid_result_event_logs do |t|
t.string :root_name, null: false, index: true
t.string :trace_id, index: true
t.integer :version, null: false
t.integer :duration, null: false, index: true
t.json :ids, null: false, default: {}
t.json :records, null: false, default: []
t.timestamps
end
create_table :accounts do |t|
t.string :uuid, null: false, index: {unique: true}
t.timestamps
end
create_table :users do |t|
t.string :uuid, null: false, index: {unique: true}
t.string :name, null: false
t.string :email, null: false, index: {unique: true}
t.string :password_digest, null: false
t.timestamps
end
create_table :user_tokens do |t|
t.belongs_to :user, null: false, foreign_key: true, index: true
t.string :access_token, null: false
t.string :refresh_token, null: false
t.datetime :access_token_expires_at, null: false
t.datetime :refresh_token_expires_at, null: false
t.timestamps
end
create_table :account_members do |t|
t.integer :role, null: false, default: 0
t.belongs_to :user, null: false, foreign_key: true, index: true
t.belongs_to :account, null: false, foreign_key: true, index: true
t.timestamps
t.index %i[account_id role], unique: true, where: "(role = 0)"
t.index %i[account_id user_id], unique: true
end
end
end
solid-result-2.0.0/examples/multiple_listeners/lib/ 0000775 0000000 0000000 00000000000 14606620746 0022461 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/lib/event_logs_listener/ 0000775 0000000 0000000 00000000000 14606620746 0026533 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/lib/event_logs_listener/stdout.rb 0000664 0000000 0000000 00000003503 14606620746 0030403 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class EventLogsListener::Stdout
include Solid::Result::EventLogs::Listener
def initialize
@buffer = []
end
def on_start(scope:)
scope => { id:, name:, desc: }
@buffer << [id, "##{id} #{name} - #{desc}".chomp('- ')]
end
def on_record(record:)
record => { current: { id: }, result: { kind:, type: } }
method_name = record.dig(:and_then, :method_name)
@buffer << [id, " * #{kind}(#{type}) from method: #{method_name}".chomp('from method: ')]
end
MapNestedMessages = ->(event_logs, buffer, hide_given_and_continue) do
ids_level_parent = event_logs.dig(:metadata, :ids, :level_parent)
messages = buffer.filter_map { |(id, msg)| "#{' ' * ids_level_parent[id].first}#{msg}" if ids_level_parent[id] }
messages.reject! { _1.match?(/\(_(given|continue)_\)/) } if hide_given_and_continue
messages
end
def on_finish(event_logs:)
messages = MapNestedMessages[event_logs, @buffer, ENV['HIDE_GIVEN_AND_CONTINUE']]
puts messages.join("\n")
end
def before_interruption(exception:, event_logs:)
messages = MapNestedMessages[event_logs, @buffer, ENV['HIDE_GIVEN_AND_CONTINUE']]
puts messages.join("\n")
bc = ::ActiveSupport::BacktraceCleaner.new
bc.add_filter { |line| line.gsub(__dir__.sub('/lib', ''), '').sub(/\A\//, '')}
bc.add_silencer { |line| /lib\/solid\/result/.match?(line) }
bc.add_silencer { |line| line.include?(RUBY_VERSION) }
dir = "#{FileUtils.pwd[1..]}/"
listener_filename = File.basename(__FILE__).chomp('.rb')
cb = bc.clean(exception.backtrace)
cb.each { _1.sub!(dir, '') }
cb.reject! { _1.match?(/block \(\d levels?\) in|in `block in|internal:kernel|#{listener_filename}/) }
puts "\nException:\n #{exception.message} (#{exception.class})\n\nBacktrace:\n #{cb.join("\n ")}"
end
end
solid-result-2.0.0/examples/multiple_listeners/lib/runtime_breaker.rb 0000664 0000000 0000000 00000000352 14606620746 0026164 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuntimeBreaker
Interruption = Class.new(StandardError)
def self.try_to_interrupt(env:)
return unless String(ENV[env]).strip.start_with?(/1|t/)
raise Interruption, "#{env}"
end
end
solid-result-2.0.0/examples/multiple_listeners/lib/solid/ 0000775 0000000 0000000 00000000000 14606620746 0023573 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/lib/solid/result/ 0000775 0000000 0000000 00000000000 14606620746 0025111 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/multiple_listeners/lib/solid/result/event_logs_record.rb 0000664 0000000 0000000 00000001525 14606620746 0031144 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result::EventLogsRecord < ActiveRecord::Base
self.table_name = 'solid_result_event_logs'
class Listener
include ::Solid::Result::EventLogs::Listener
def on_finish(event_logs:)
metadata = event_logs[:metadata]
root_name = event_logs.dig(:records, 0, :root, :name) || 'Unknown'
Solid::Result::EventLogsRecord.create(
root_name: root_name,
trace_id: metadata[:trace_id],
version: event_logs[:version],
duration: metadata[:duration],
ids: metadata[:ids],
records: event_logs[:records]
)
rescue ::StandardError => e
err = "#{e.message} (#{e.class}); Backtrace: #{e.backtrace.join(', ')}"
::Kernel.warn "Error on Solid::Result::EventLogsRecord::Listener#on_finish: #{err}"
end
end
end
solid-result-2.0.0/examples/multiple_listeners/lib/solid/result/rollback_on_failure.rb 0000664 0000000 0000000 00000000425 14606620746 0031433 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::RollbackOnFailure
def rollback_on_failure(model: ::ActiveRecord::Base)
result = nil
model.transaction do
result = yield
raise ::ActiveRecord::Rollback if result.failure?
end
result
end
end
solid-result-2.0.0/examples/service_objects/ 0000775 0000000 0000000 00000000000 14606620746 0021141 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/Rakefile 0000664 0000000 0000000 00000001400 14606620746 0022601 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
if RUBY_VERSION <= '3.1'
puts 'This example requires Ruby 3.1 or higher.'
exit! 1
end
task default: %i[solid_result_event_logs]
task :config do
require_relative 'config'
end
desc 'creates an account and an owner user through Solid::Result'
task solid_result_event_logs: %i[config] do
result1 = Account::OwnerCreation.call(
owner: {
name: "\tJohn Doe \n",
email: ' JOHN.doe@email.com',
password: '123123123',
password_confirmation: '123123123'
}
)
puts result1.inspect
puts
result2 = Account::OwnerCreation.call(
uuid: "",
owner: {}
).on_failure(:invalid_input) do |output|
output[:input].errors.full_messages.each do |message|
puts message
end
end
end
solid-result-2.0.0/examples/service_objects/app/ 0000775 0000000 0000000 00000000000 14606620746 0021721 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/app/models/ 0000775 0000000 0000000 00000000000 14606620746 0023204 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/app/models/account.rb 0000664 0000000 0000000 00000000720 14606620746 0025164 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account < ActiveRecord::Base
has_many :memberships, inverse_of: :account, dependent: :destroy, class_name: '::Account::Member'
has_many :users, through: :memberships, inverse_of: :accounts
where_ownership = -> { where(account_members: {role: :owner}) }
has_one :ownership, where_ownership, dependent: nil, inverse_of: :account, class_name: '::Account::Member'
has_one :owner, through: :ownership, source: :user
end
solid-result-2.0.0/examples/service_objects/app/models/account/ 0000775 0000000 0000000 00000000000 14606620746 0024640 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/app/models/account/member.rb 0000664 0000000 0000000 00000000407 14606620746 0026435 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account::Member < ActiveRecord::Base
self.table_name = 'account_members'
enum role: { owner: 0, admin: 1, contributor: 2 }
belongs_to :user, inverse_of: :memberships
belongs_to :account, inverse_of: :memberships
end
solid-result-2.0.0/examples/service_objects/app/models/user.rb 0000664 0000000 0000000 00000001056 14606620746 0024511 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User < ActiveRecord::Base
has_secure_password
has_many :memberships, inverse_of: :user, dependent: :destroy, class_name: '::Account::Member'
has_many :accounts, through: :memberships, inverse_of: :users
where_ownership = -> { where(account_members: { role: :owner }) }
has_one :ownership, where_ownership, inverse_of: :user, class_name: '::Account::Member'
has_one :account, through: :ownership, inverse_of: :owner
has_one :token, inverse_of: :user, dependent: :destroy, class_name: '::User::Token'
end
solid-result-2.0.0/examples/service_objects/app/models/user/ 0000775 0000000 0000000 00000000000 14606620746 0024162 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/app/models/user/token.rb 0000664 0000000 0000000 00000000224 14606620746 0025625 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token < ActiveRecord::Base
self.table_name = 'user_tokens'
belongs_to :user, inverse_of: :token
end
solid-result-2.0.0/examples/service_objects/app/services/ 0000775 0000000 0000000 00000000000 14606620746 0023544 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/app/services/account/ 0000775 0000000 0000000 00000000000 14606620746 0025200 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/app/services/account/owner_creation.rb 0000664 0000000 0000000 00000002434 14606620746 0030546 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account
class OwnerCreation < ApplicationService
input do
attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
attribute :owner
before_validation do |input|
input.uuid = input.uuid.strip.downcase
end
validates :uuid, presence: true, format: { with: /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i }
validates :owner, presence: true, type: ::Hash
end
def call(attributes)
rollback_on_failure {
Given(attributes)
.and_then(:create_owner)
.and_then(:create_account)
.and_then(:link_owner_to_account)
}.and_expose(:account_owner_created, %i[user account])
end
private
def create_owner(owner:, **)
::User::Creation.call(owner).handle do |on|
on.success { |output| Continue(user: output[:user], token: output[:token]) }
on.failure { |output| Failure(:invalid_owner, **output) }
end
end
def create_account(uuid:, **)
account = ::Account.create(uuid:)
account.persisted? ? Continue(account:) : Failure(:invalid_record, **account.errors.messages)
end
def link_owner_to_account(account:, user:, **)
Member.create!(account:, user:, role: :owner)
Continue()
end
end
end
solid-result-2.0.0/examples/service_objects/app/services/application_service.rb 0000664 0000000 0000000 00000003215 14606620746 0030115 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class ApplicationService
Error = ::Class.new(::StandardError)
class Input
def self.inherited(subclass)
subclass.include ::ActiveModel::API
subclass.include ::ActiveModel::Attributes
subclass.include ::ActiveModel::Dirty
subclass.include ::ActiveModel::Validations::Callbacks
end
end
class << self
def input=(klass)
const_defined?(:Input, false) and raise ArgumentError, "#{self}::Input class already defined"
unless klass.is_a?(::Class) && klass < Input
raise ArgumentError, 'must be a ApplicationService::Input subclass'
end
const_set(:Input, klass)
end
def input(&block)
return const_get(:Input, false) if const_defined?(:Input, false)
klass = ::Class.new(Input)
klass.class_eval(&block)
self.input = klass
end
def inherited(subclass)
subclass.include ::Solid::Output.mixin(config: { addon: { continue: true } })
end
def call(arg)
new(input.new(arg)).call!
end
end
private_class_method :new
attr_reader :input
def initialize(input)
@input = input
end
def call!
::Solid::Result.event_logs(name: self.class.name) do
if input.invalid?
Failure(:invalid_input, input: input)
else
call(input.attributes.deep_symbolize_keys)
end
end
end
def call(attributes)
raise Error, 'must be implemented in a subclass'
end
private
def rollback_on_failure(model: ::ActiveRecord::Base)
result = nil
model.transaction do
result = yield
raise ::ActiveRecord::Rollback if result.failure?
end
result
end
end
solid-result-2.0.0/examples/service_objects/app/services/user/ 0000775 0000000 0000000 00000000000 14606620746 0024522 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/app/services/user/creation.rb 0000664 0000000 0000000 00000003371 14606620746 0026657 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User
class Creation < ApplicationService
input do
attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
attribute :name, :string
attribute :email, :string
attribute :password, :string
attribute :password_confirmation, :string
before_validation do |input|
input.uuid = input.uuid.strip.downcase
input.name = input.name.strip.gsub(/\s+/, ' ')
input.email = input.email.strip.downcase
end
validates :uuid, presence: true, format: { with: /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i }
validates :name, presence: true
validates :email, presence: true, format: { with: ::URI::MailTo::EMAIL_REGEXP }
validates :password, :password_confirmation, presence: true
end
def call(attributes)
Given(attributes)
.and_then(:validate_email_uniqueness)
.then { |result|
rollback_on_failure {
result
.and_then(:create_user)
.and_then(:create_user_token)
}
}
.and_expose(:user_created, %i[user token])
end
private
def validate_email_uniqueness(email:, **)
::User.exists?(email:) ? Failure(:email_already_taken) : Continue()
end
def create_user(uuid:, name:, email:, password:, password_confirmation:)
user = ::User.create(uuid:, name:, email:, password:, password_confirmation:)
user.persisted? ? Continue(user:) : Failure(:invalid_record, **user.errors.messages)
end
def create_user_token(user:, **)
Token::Creation.call(user: user).handle do |on|
on.success { |output| Continue(token: output[:token]) }
on.failure { raise 'Token creation failed' }
end
end
end
end
solid-result-2.0.0/examples/service_objects/app/services/user/token/ 0000775 0000000 0000000 00000000000 14606620746 0025642 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/app/services/user/token/creation.rb 0000664 0000000 0000000 00000002002 14606620746 0027765 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token
class Creation < ApplicationService
input do
attribute :user
attribute :executed_at, :time, default: -> { ::Time.current }
validates :user, presence: true, type: ::User
validates :executed_at, presence: true
end
def call(attributes)
Given(attributes)
.and_then(:validate_token_existence)
.and_then(:create_token)
.and_expose(:token_created, %i[token])
end
private
def validate_token_existence(user:, **)
user.token.nil? ? Continue() : Failure(:token_already_exists)
end
def create_token(user:, executed_at:, **)
token = user.create_token(
access_token: ::SecureRandom.hex(24),
refresh_token: ::SecureRandom.hex(24),
access_token_expires_at: executed_at + 15.days,
refresh_token_expires_at: executed_at + 30.days
)
token.persisted? ? Continue(token:) : Failure(:token_creation_failed, **token.errors.messages)
end
end
end
solid-result-2.0.0/examples/service_objects/config.rb 0000664 0000000 0000000 00000000743 14606620746 0022737 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'bundler/inline'
$LOAD_PATH.unshift(__dir__)
require_relative 'config/boot'
require_relative 'config/initializers/solid_result'
require 'db/setup'
require 'app/models/account'
require 'app/models/account/member'
require 'app/models/user'
require 'app/models/user/token'
require 'app/services/application_service'
require 'app/services/account/owner_creation'
require 'app/services/user/token/creation'
require 'app/services/user/creation'
solid-result-2.0.0/examples/service_objects/config/ 0000775 0000000 0000000 00000000000 14606620746 0022406 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/config/boot.rb 0000664 0000000 0000000 00000000533 14606620746 0023677 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'bundler/inline'
$LOAD_PATH.unshift(__dir__)
gemfile do
source 'https://rubygems.org'
gem 'sqlite3', '~> 1.7'
gem 'bcrypt', '~> 3.1.20'
gem 'activerecord', '~> 7.1', '>= 7.1.3', require: 'active_record'
gem 'type_validator'
gem 'solid-result', path: '../../'
end
require 'active_support/all'
solid-result-2.0.0/examples/service_objects/config/initializers/ 0000775 0000000 0000000 00000000000 14606620746 0025114 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/config/initializers/solid_result.rb 0000664 0000000 0000000 00000000362 14606620746 0030152 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
Solid::Result.config.then do |config|
config.addon.enable!(:continue)
config.pattern_matching.disable!(:nil_as_valid_value_checking)
# config.feature.disable!(:expectations) if Rails.env.production?
end
solid-result-2.0.0/examples/service_objects/db/ 0000775 0000000 0000000 00000000000 14606620746 0021526 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/service_objects/db/setup.rb 0000664 0000000 0000000 00000002451 14606620746 0023215 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'active_support/all'
ActiveRecord::Base.establish_connection(
host: 'localhost',
adapter: 'sqlite3',
database: ':memory:'
)
ActiveRecord::Schema.define do
suppress_messages do
create_table :accounts do |t|
t.string :uuid, null: false, index: {unique: true}
t.timestamps
end
create_table :users do |t|
t.string :uuid, null: false, index: {unique: true}
t.string :name, null: false
t.string :email, null: false, index: {unique: true}
t.string :password_digest, null: false
t.timestamps
end
create_table :user_tokens do |t|
t.belongs_to :user, null: false, foreign_key: true, index: true
t.string :access_token, null: false
t.string :refresh_token, null: false
t.datetime :access_token_expires_at, null: false
t.datetime :refresh_token_expires_at, null: false
t.timestamps
end
create_table :account_members do |t|
t.integer :role, null: false, default: 0
t.belongs_to :user, null: false, foreign_key: true, index: true
t.belongs_to :account, null: false, foreign_key: true, index: true
t.timestamps
t.index %i[account_id role], unique: true, where: "(role = 0)"
t.index %i[account_id user_id], unique: true
end
end
end
solid-result-2.0.0/examples/single_listener/ 0000775 0000000 0000000 00000000000 14606620746 0021156 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/Rakefile 0000664 0000000 0000000 00000004336 14606620746 0022631 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
if RUBY_VERSION <= '3.1'
puts 'This example requires Ruby 3.1 or higher.'
exit! 1
end
# Usage:
#
# rake DISABLE_EVENT_LOGS=t
# rake DISABLE_LISTENER=t
#
# rake HIDE_GIVEN_AND_CONTINUE=t
#
# rake BREAK_ACCOUNT_CREATION=t
# rake BREAK_USER_CREATION=t
# rake BREAK_USER_TOKEN_CREATION=t
#
# rake BREAK_ACCOUNT_CREATION=t HIDE_GIVEN_AND_CONTINUE=t
task default: %i[solid_result_event_logs]
task :config do
require_relative 'config'
end
desc 'creates an account and an owner user through Solid::Result'
task solid_result_event_logs: %i[config] do
Solid::Result.configuration do |config|
config.feature.disable!(:event_logs) if ENV['DISABLE_EVENT_LOGS']
config.event_logs.listener = SingleEventLogsListener unless ENV['DISABLE_LISTENER']
end
result = nil
bench = Benchmark.measure do
result = Account::OwnerCreation.new.call(
owner: {
name: "\tJohn Doe \n",
email: ' JOHN.doe@email.com',
password: '123123123',
password_confirmation: '123123123'
}
)
rescue RuntimeBreaker::Interruption => e
nil
end
puts "\nBenchmark: #{bench}"
end
desc 'creates an account and an owner user directly through ActiveRecord'
task raw_active_record: %i[config] do
require_relative 'config'
result = nil
bench = Benchmark.measure do
email = 'john.doe@email.com'
ActiveRecord::Base.transaction do
User.exists?(email:) and raise "User with email #{email} already exists"
user = User.create!(
uuid: ::SecureRandom.uuid,
name: 'John Doe',
email:,
password: '123123123',
password_confirmation: '123123123'
)
executed_at = ::Time.current
user.token.nil? or raise "User with email #{email} already has a token"
user.create_token!(
access_token: ::SecureRandom.hex(24),
refresh_token: ::SecureRandom.hex(24),
access_token_expires_at: executed_at + 15.days,
refresh_token_expires_at: executed_at + 30.days
)
account = Account.create!(uuid: ::SecureRandom.uuid)
Account::Member.create!(account: account, user: user, role: :owner)
result = { account: account, user: user }
end
end
puts "\nBenchmark: #{bench}"
end
solid-result-2.0.0/examples/single_listener/app/ 0000775 0000000 0000000 00000000000 14606620746 0021736 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/app/models/ 0000775 0000000 0000000 00000000000 14606620746 0023221 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/app/models/account.rb 0000664 0000000 0000000 00000000720 14606620746 0025201 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account < ActiveRecord::Base
has_many :memberships, inverse_of: :account, dependent: :destroy, class_name: '::Account::Member'
has_many :users, through: :memberships, inverse_of: :accounts
where_ownership = -> { where(account_members: {role: :owner}) }
has_one :ownership, where_ownership, dependent: nil, inverse_of: :account, class_name: '::Account::Member'
has_one :owner, through: :ownership, source: :user
end
solid-result-2.0.0/examples/single_listener/app/models/account/ 0000775 0000000 0000000 00000000000 14606620746 0024655 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/app/models/account/member.rb 0000664 0000000 0000000 00000000407 14606620746 0026452 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account::Member < ActiveRecord::Base
self.table_name = 'account_members'
enum role: { owner: 0, admin: 1, contributor: 2 }
belongs_to :user, inverse_of: :memberships
belongs_to :account, inverse_of: :memberships
end
solid-result-2.0.0/examples/single_listener/app/models/account/owner_creation.rb 0000664 0000000 0000000 00000003433 14606620746 0030223 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account
class OwnerCreation
include Solid::Output.mixin
include Solid::Result::RollbackOnFailure
def call(**input)
Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
.then { |result|
rollback_on_failure {
result
.and_then(:create_owner)
.and_then(:create_account)
.and_then(:link_owner_to_account)
}
}.and_expose(:account_owner_created, %i[user account])
end
end
private
def normalize_input(**options)
uuid = String(options.fetch(:uuid) { ::SecureRandom.uuid }).strip.downcase
Continue(uuid:)
end
def validate_input(uuid:, owner:)
err = ::Hash.new { |hash, key| hash[key] = [] }
err[:uuid] << 'must be an UUID' unless uuid.match?(/\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i)
err[:owner] << 'must be a Hash' unless owner.is_a?(::Hash)
err.empty? ? Continue() : Failure(:invalid_input, **err)
end
def create_owner(owner:, **)
::User::Creation.new.call(**owner).handle do |on|
on.success { |output| Continue(user: { record: output[:user], token: output[:token] }) }
on.failure { |output| Failure(:invalid_owner, **output) }
end
end
def create_account(uuid:, **)
::RuntimeBreaker.try_to_interrupt(env: 'BREAK_ACCOUNT_CREATION')
account = ::Account.create(uuid:)
account.persisted? ? Continue(account:) : Failure(:invalid_record, **account.errors.messages)
end
def link_owner_to_account(account:, user:, **)
Member.create!(account:, user: user.fetch(:record), role: :owner)
Continue()
end
end
end
solid-result-2.0.0/examples/single_listener/app/models/user.rb 0000664 0000000 0000000 00000001056 14606620746 0024526 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User < ActiveRecord::Base
has_secure_password
has_many :memberships, inverse_of: :user, dependent: :destroy, class_name: '::Account::Member'
has_many :accounts, through: :memberships, inverse_of: :users
where_ownership = -> { where(account_members: { role: :owner }) }
has_one :ownership, where_ownership, inverse_of: :user, class_name: '::Account::Member'
has_one :account, through: :ownership, inverse_of: :owner
has_one :token, inverse_of: :user, dependent: :destroy, class_name: '::User::Token'
end
solid-result-2.0.0/examples/single_listener/app/models/user/ 0000775 0000000 0000000 00000000000 14606620746 0024177 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/app/models/user/creation.rb 0000664 0000000 0000000 00000004244 14606620746 0026334 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User
class Creation
include Solid::Output.mixin
include Solid::Result::RollbackOnFailure
def call(**input)
Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
.and_then(:validate_email_uniqueness)
.then { |result|
rollback_on_failure {
result
.and_then(:create_user)
.and_then(:create_user_token)
}
}
.and_expose(:user_created, %i[user token])
end
end
private
def normalize_input(name:, email:, **options)
name = String(name).strip.gsub(/\s+/, ' ')
email = String(email).strip.downcase
uuid = String(options.fetch(:uuid) { ::SecureRandom.uuid }).strip.downcase
Continue(uuid:, name:, email:)
end
def validate_input(uuid:, name:, email:, password:, password_confirmation:)
err = ::Hash.new { |hash, key| hash[key] = [] }
err[:uuid] << 'must be an UUID' unless uuid.match?(/\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i)
err[:name] << 'must be present' if name.blank?
err[:email] << 'must be email' unless email.match?(::URI::MailTo::EMAIL_REGEXP)
err[:password] << 'must be present' if password.blank?
err[:password_confirmation] << 'must be present' if password_confirmation.blank?
err.empty? ? Continue() : Failure(:invalid_input, **err)
end
def validate_email_uniqueness(email:, **)
::User.exists?(email:) ? Failure(:email_already_taken) : Continue()
end
def create_user(uuid:, name:, email:, password:, password_confirmation:)
::RuntimeBreaker.try_to_interrupt(env: 'BREAK_USER_CREATION')
user = ::User.create(uuid:, name:, email:, password:, password_confirmation:)
user.persisted? ? Continue(user:) : Failure(:invalid_record, **user.errors.messages)
end
def create_user_token(user:, **)
Token::Creation.new.call(user: user).handle do |on|
on.success { |output| Continue(token: output[:token]) }
on.failure { raise 'Token creation failed' }
end
end
end
end
solid-result-2.0.0/examples/single_listener/app/models/user/token.rb 0000664 0000000 0000000 00000000224 14606620746 0025642 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token < ActiveRecord::Base
self.table_name = 'user_tokens'
belongs_to :user, inverse_of: :token
end
solid-result-2.0.0/examples/single_listener/app/models/user/token/ 0000775 0000000 0000000 00000000000 14606620746 0025317 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/app/models/user/token/creation.rb 0000664 0000000 0000000 00000003011 14606620746 0027443 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token
class Creation
include Solid::Output.mixin
def call(**input)
Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
.and_then(:validate_token_existence)
.and_then(:create_token)
.and_expose(:token_created, %i[token])
end
end
private
def normalize_input(**options)
Continue(executed_at: options.fetch(:executed_at) { ::Time.current })
end
def validate_input(user:, executed_at:)
err = ::Hash.new { |hash, key| hash[key] = [] }
err[:user] << 'must be a User' unless user.is_a?(::User)
err[:user] << 'must be persisted' unless user.try(:persisted?)
err[:executed_at] << 'must be a time' unless executed_at.is_a?(::Time)
err.empty? ? Continue() : Failure(:invalid_user, **err)
end
def validate_token_existence(user:, **)
user.token.nil? ? Continue() : Failure(:token_already_exists)
end
def create_token(user:, executed_at:, **)
::RuntimeBreaker.try_to_interrupt(env: 'BREAK_USER_TOKEN_CREATION')
token = user.create_token(
access_token: ::SecureRandom.hex(24),
refresh_token: ::SecureRandom.hex(24),
access_token_expires_at: executed_at + 15.days,
refresh_token_expires_at: executed_at + 30.days
)
token.persisted? ? Continue(token:) : Failure(:token_creation_failed, **token.errors.messages)
end
end
end
solid-result-2.0.0/examples/single_listener/config.rb 0000664 0000000 0000000 00000001051 14606620746 0022745 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'bundler/inline'
$LOAD_PATH.unshift(__dir__)
require_relative 'config/boot'
require_relative 'config/initializers/solid_result'
require 'db/setup'
require 'lib/solid/result/rollback_on_failure'
require 'lib/single_event_logs_listener'
require 'lib/runtime_breaker'
require 'app/models/account'
require 'app/models/account/member'
require 'app/models/user'
require 'app/models/user/token'
require 'app/models/account/owner_creation'
require 'app/models/user/token/creation'
require 'app/models/user/creation'
solid-result-2.0.0/examples/single_listener/config/ 0000775 0000000 0000000 00000000000 14606620746 0022423 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/config/boot.rb 0000664 0000000 0000000 00000000504 14606620746 0023712 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'bundler/inline'
$LOAD_PATH.unshift(__dir__)
gemfile do
source 'https://rubygems.org'
gem 'sqlite3', '~> 1.7'
gem 'bcrypt', '~> 3.1.20'
gem 'activerecord', '~> 7.1', '>= 7.1.3', require: 'active_record'
gem 'solid-result', path: '../../'
end
require 'active_support/all'
solid-result-2.0.0/examples/single_listener/config/initializers/ 0000775 0000000 0000000 00000000000 14606620746 0025131 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/config/initializers/solid_result.rb 0000664 0000000 0000000 00000000362 14606620746 0030167 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
Solid::Result.config.then do |config|
config.addon.enable!(:continue)
config.pattern_matching.disable!(:nil_as_valid_value_checking)
# config.feature.disable!(:expectations) if Rails.env.production?
end
solid-result-2.0.0/examples/single_listener/db/ 0000775 0000000 0000000 00000000000 14606620746 0021543 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/db/setup.rb 0000664 0000000 0000000 00000002451 14606620746 0023232 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'active_support/all'
ActiveRecord::Base.establish_connection(
host: 'localhost',
adapter: 'sqlite3',
database: ':memory:'
)
ActiveRecord::Schema.define do
suppress_messages do
create_table :accounts do |t|
t.string :uuid, null: false, index: {unique: true}
t.timestamps
end
create_table :users do |t|
t.string :uuid, null: false, index: {unique: true}
t.string :name, null: false
t.string :email, null: false, index: {unique: true}
t.string :password_digest, null: false
t.timestamps
end
create_table :user_tokens do |t|
t.belongs_to :user, null: false, foreign_key: true, index: true
t.string :access_token, null: false
t.string :refresh_token, null: false
t.datetime :access_token_expires_at, null: false
t.datetime :refresh_token_expires_at, null: false
t.timestamps
end
create_table :account_members do |t|
t.integer :role, null: false, default: 0
t.belongs_to :user, null: false, foreign_key: true, index: true
t.belongs_to :account, null: false, foreign_key: true, index: true
t.timestamps
t.index %i[account_id role], unique: true, where: "(role = 0)"
t.index %i[account_id user_id], unique: true
end
end
end
solid-result-2.0.0/examples/single_listener/lib/ 0000775 0000000 0000000 00000000000 14606620746 0021724 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/lib/runtime_breaker.rb 0000664 0000000 0000000 00000000406 14606620746 0025427 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuntimeBreaker
Interruption = Class.new(StandardError)
def self.try_to_interrupt(env:)
return unless String(ENV[env]).strip.start_with?(/1|t/)
raise Interruption, "Runtime breaker activated (#{env})"
end
end
solid-result-2.0.0/examples/single_listener/lib/single_event_logs_listener.rb 0000664 0000000 0000000 00000007721 14606620746 0027673 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class SingleEventLogsListener
include Solid::Result::EventLogs::Listener
# A listener will be initialized before the first event log, and it is discarded after the last one.
def initialize
@buffer = []
end
# This method will be called before each event log block.
# The parent event log block will be called first in the case of nested blocks.
#
# @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
def on_start(scope:)
scope => { id:, name:, desc: }
@buffer << [id, "##{id} #{name} - #{desc}".chomp('- ')]
end
# This method will wrap all the event_logs in the same block.
# It can be used to perform an instrumentation (measure/report) of the event_logs.
#
# @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
def around_event_logs(scope:)
yield
end
# This method will wrap each and_then call.
# It can be used to perform an instrumentation (measure/report) of the and_then calls.
#
# @param scope: {:id=>1, :name=>"SomeOperation", :desc=>"Optional description"}
# @param and_then:
# {:type=>:block, :arg=>:some_injected_value}
# {:type=>:method, :arg=>:some_injected_value, :method_name=>:some_method_name}
def around_and_then(scope:, and_then:)
yield
end
# This method will be called after each result recording/tracking.
#
# @param record:
# {
# :root => {:id=>0, :name=>"RootOperation", :desc=>nil},
# :parent => {:id=>0, :name=>"RootOperation", :desc=>nil},
# :current => {:id=>1, :name=>"SomeOperation", :desc=>nil},
# :result => {:kind=>:success, :type=>:_continue_, :value=>{some: :thing}, :source=>},
# :and_then => {:type=>:method, :arg=>nil, :method_name=>:some_method},
# :time => 2024-01-26 02:53:11.310431 UTC
# }
def on_record(record:)
record => { current: { id: }, result: { kind:, type: } }
method_name = record.dig(:and_then, :method_name)
@buffer << [id, " * #{kind}(#{type}) from method: #{method_name}".chomp('from method: ')]
end
MapNestedMessages = ->(event_logs, buffer, hide_given_and_continue) do
ids_level_parent = event_logs.dig(:metadata, :ids, :level_parent)
messages = buffer.filter_map { |(id, msg)| "#{' ' * ids_level_parent[id].first}#{msg}" if ids_level_parent[id] }
messages.reject! { _1.match?(/\(_(given|continue)_\)/) } if hide_given_and_continue
messages
end
# This method will be called at the end of the event_logs tracking.
#
# @param event_logs:
# {
# :version => 1,
# :metadata => {
# :duration => 0,
# :trace_id => nil,
# :ids => {
# :tree => [0, [[1, []], [2, []]]],
# :matrix => { 0 => [0, 0], 1 => [1, 1], 2 => [2, 1]},
# :level_parent => { 0 => [0, 0], 1 => [1, 0], 2 => [1, 0]}
# }
# },
# :records => [
# # ...
# ]
# }
def on_finish(event_logs:)
messages = MapNestedMessages[event_logs, @buffer, ENV['HIDE_GIVEN_AND_CONTINUE']]
puts messages.join("\n")
end
# This method will be called when an exception is raised during the event_logs tracking.
#
# @param exception: Exception
# @param event_logs: Hash
def before_interruption(exception:, event_logs:)
messages = MapNestedMessages[event_logs, @buffer, ENV['HIDE_GIVEN_AND_CONTINUE']]
puts messages.join("\n")
bc = ::ActiveSupport::BacktraceCleaner.new
bc.add_filter { |line| line.gsub(__dir__.sub('/lib', ''), '').sub(/\A\//, '')}
bc.add_silencer { |line| /lib\/solid\/result/.match?(line) }
bc.add_silencer { |line| line.include?(RUBY_VERSION) }
dir = "#{FileUtils.pwd[1..]}/"
listener_filename = File.basename(__FILE__).chomp('.rb')
cb = bc.clean(exception.backtrace)
cb.each { _1.sub!(dir, '') }
cb.reject! { _1.match?(/block \(\d levels?\) in|in `block in|internal:kernel|#{listener_filename}/) }
puts "\nException:\n #{exception.message} (#{exception.class})\n\nBacktrace:\n #{cb.join("\n ")}"
end
end
solid-result-2.0.0/examples/single_listener/lib/solid/ 0000775 0000000 0000000 00000000000 14606620746 0023036 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/lib/solid/result/ 0000775 0000000 0000000 00000000000 14606620746 0024354 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/examples/single_listener/lib/solid/result/rollback_on_failure.rb 0000664 0000000 0000000 00000000425 14606620746 0030676 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::RollbackOnFailure
def rollback_on_failure(model: ::ActiveRecord::Base)
result = nil
model.transaction do
result = yield
raise ::ActiveRecord::Rollback if result.failure?
end
result
end
end
solid-result-2.0.0/lib/ 0000775 0000000 0000000 00000000000 14606620746 0014720 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid-result.rb 0000664 0000000 0000000 00000000066 14606620746 0017675 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'solid/result'
solid-result-2.0.0/lib/solid/ 0000775 0000000 0000000 00000000000 14606620746 0016032 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/failure.rb 0000664 0000000 0000000 00000000465 14606620746 0020013 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
module Failure
def success?(_type = nil)
false
end
def failure?(type = nil)
type.nil? || type_checker.allow_failure?([type])
end
def value_or
yield(value)
end
private
def kind
:failure
end
end
end
solid-result-2.0.0/lib/solid/output.rb 0000664 0000000 0000000 00000005170 14606620746 0017722 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Output < Solid::Result
require_relative 'output/failure'
require_relative 'output/success'
require_relative 'output/mixin'
require_relative 'output/expectations'
require_relative 'output/callable_and_then'
EXPECTED_OUTCOME = 'Solid::Output::Success or Solid::Output::Failure'
def self.Success(type, **value)
Success.new(type: type, value: value)
end
def self.Failure(type, **value)
Failure.new(type: type, value: value)
end
def initialize(type:, value:, source: nil, expectations: nil, terminal: nil)
value.is_a?(::Hash) or raise ::ArgumentError, 'value must be a Hash'
@memo = {}
super
end
def and_then(method_name = nil, **injected_value, &block)
super(method_name, injected_value, &block)
end
def and_then!(source, **injected_value)
_call = injected_value.delete(:_call)
memo.merge!(injected_value)
super(source, injected_value, _call: _call)
end
def [](key)
value[key]
end
def dig(...)
value.dig(...)
end
def fetch(...)
value.fetch(...)
end
def slice(...)
value.slice(...)
end
def values_at(...)
value.values_at(...)
end
def fetch_values(...)
value.fetch_values(...)
end
protected
attr_reader :memo
private
SourceMethodArity = ->(method) do
return 0 if method.arity.zero?
parameters = method.parameters.map(&:first)
return 1 if !parameters.empty? && parameters.all?(/\Akey/)
-1
end
def call_and_then_source_method!(method, injected_value)
memo.merge!(value.merge(injected_value))
case SourceMethodArity[method]
when 0 then source.send(method.name)
when 1 then source.send(method.name, **memo)
else raise Error::InvalidSourceMethodArity.build(source: source, method: method, max_arity: 1)
end
end
def call_and_then_block!(block)
memo.merge!(value)
block.call(memo)
end
def call_and_then_callable!(source, value:, injected_value:, method_name:)
memo.merge!(value.merge(injected_value))
CallableAndThen::Caller.call(source, value: memo, injected_value: injected_value, method_name: method_name)
end
def ensure_result_object(result, origin:)
raise_unexpected_outcome_error(result, origin) unless result.is_a?(Solid::Output)
return result.tap { _1.memo.merge!(memo) } if result.source.equal?(source)
raise Error::InvalidResultSource.build(given_result: result, expected_source: source)
end
def raise_unexpected_outcome_error(result, origin)
raise Error::UnexpectedOutcome.build(outcome: result, origin: origin, expected: EXPECTED_OUTCOME)
end
private_constant :SourceMethodArity
end
solid-result-2.0.0/lib/solid/output/ 0000775 0000000 0000000 00000000000 14606620746 0017372 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/output/callable_and_then.rb 0000664 0000000 0000000 00000002466 14606620746 0023326 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
module Output::CallableAndThen
class Caller < Result::CallableAndThen::Caller
module KeyArgs
def self.parameters?(source)
parameters = source.parameters.map(&:first)
!parameters.empty? && parameters.all?(/\Akey/)
end
def self.invalid_arity(source, method)
Result::CallableAndThen::Error::InvalidArity.build(source: source, method: method, arity: 'only keyword args')
end
end
def self.call_proc!(source, value, _injected_value)
return source.call(**value) if KeyArgs.parameters?(source)
raise KeyArgs.invalid_arity(source, :call)
end
def self.call_method!(source, method, value, _injected_value)
return source.send(method.name, **value) if KeyArgs.parameters?(method)
raise KeyArgs.invalid_arity(source, method.name)
end
def self.ensure_result_object(source, value, result)
return result.tap { result.send(:memo).then { _1.merge!(value.merge(_1)) } } if result.is_a?(Output)
raise Result::Error::UnexpectedOutcome.build(outcome: result, origin: source,
expected: Output::EXPECTED_OUTCOME)
end
private_class_method :call_proc!, :call_method!
end
end
end
solid-result-2.0.0/lib/solid/output/expectations.rb 0000664 0000000 0000000 00000001014 14606620746 0022421 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Output
class Expectations < Solid::Result::Expectations
require_relative 'expectations/mixin'
def self.mixin_module
Mixin
end
def self.result_factory_without_expectations
::Solid::Output
end
private_class_method :mixin!, :mixin_module, :result_factory_without_expectations
def Success(type, **value)
_ResultAs(Success, type, value)
end
def Failure(type, **value)
_ResultAs(Failure, type, value)
end
end
end
solid-result-2.0.0/lib/solid/output/expectations/ 0000775 0000000 0000000 00000000000 14606620746 0022100 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/output/expectations/mixin.rb 0000664 0000000 0000000 00000001433 14606620746 0023552 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Output
module Expectations::Mixin
Factory = Solid::Result::Expectations::Mixin::Factory
Methods = Solid::Result::Expectations::Mixin::Methods
module Addons
module Continue
private def Continue(**value)
Success(::Solid::Result::IgnoredTypes::CONTINUE, **value)
end
end
module Given
private def Given(*values)
value = values.map(&:to_h).reduce({}) { |acc, val| acc.merge(val) }
Success(::Solid::Result::IgnoredTypes::GIVEN, **value)
end
end
OPTIONS = { continue: Continue, given: Given }.freeze
def self.options(config_flags)
::Solid::Result::Config::Options.addon(map: config_flags, from: OPTIONS)
end
end
end
end
solid-result-2.0.0/lib/solid/output/failure.rb 0000664 0000000 0000000 00000000246 14606620746 0021350 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Output::Failure < Solid::Output
include ::Solid::Failure
def and_expose(_type, _keys, **_options)
self
end
end
solid-result-2.0.0/lib/solid/output/mixin.rb 0000664 0000000 0000000 00000002472 14606620746 0021050 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Output
module Mixin
Factory = Solid::Result::Mixin::Factory
module Methods
def Success(type, **value)
_ResultAs(Success, type, value)
end
def Failure(type, **value)
_ResultAs(Failure, type, value)
end
private def _ResultAs(kind_class, type, value, terminal: nil)
kind_class.new(type: type, value: value, source: self, terminal: terminal)
end
end
module Addons
module Continue
def Success(type, **value)
_ResultAs(Success, type, value, terminal: true)
end
private def Continue(**value)
_ResultAs(Success, ::Solid::Result::IgnoredTypes::CONTINUE, value)
end
end
module Given
private def Given(*values)
value = values.map(&:to_h).reduce({}) { |acc, val| acc.merge(val) }
_ResultAs(Success, ::Solid::Result::IgnoredTypes::GIVEN, value)
end
end
OPTIONS = { continue: Continue, given: Given }.freeze
def self.options(config_flags)
::Solid::Result::Config::Options.addon(map: config_flags, from: OPTIONS)
end
end
end
def self.mixin_module
Mixin
end
def self.result_factory
::Solid::Output
end
private_class_method :mixin_module, :result_factory
end
solid-result-2.0.0/lib/solid/output/success.rb 0000664 0000000 0000000 00000002004 14606620746 0021363 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Output
class Error < Solid::Result::Error
InvalidExposure = ::Class.new(self)
end
class Success < self
include ::Solid::Success
FetchValues = ->(memo_values, keys) do
fetched_values = memo_values.fetch_values(*keys)
keys.zip(fetched_values).to_h
rescue ::KeyError => e
message = "#{e.message}. Available to expose: #{memo_values.keys.map(&:inspect).join(', ')}"
raise Error::InvalidExposure, message
end
def and_expose(type, keys, terminal: true)
unless keys.is_a?(::Array) && !keys.empty? && keys.all?(::Symbol)
raise ::ArgumentError, 'keys must be an Array of Symbols'
end
EventLogs.tracking.reset_and_then!
memo_values = memo.merge(value)
value_to_expose = FetchValues.call(memo_values, keys)
expectations = type_checker.expectations
self.class.new(type: type, value: value_to_expose, source: source, terminal: terminal, expectations: expectations)
end
end
end
solid-result-2.0.0/lib/solid/result.rb 0000664 0000000 0000000 00000001321 14606620746 0017672 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'set'
module Solid
require_relative 'success'
require_relative 'failure'
class Result
require_relative 'result/version'
require_relative 'result/error'
require_relative 'result/ignored_types'
require_relative 'result/event_logs'
require_relative 'result/callable_and_then'
require_relative 'result/data'
require_relative 'result/handler'
require_relative 'result/failure'
require_relative 'result/success'
require_relative 'result/mixin'
require_relative 'result/contract'
require_relative 'result/expectations'
require_relative 'result/config'
require_relative 'result/_self'
require_relative 'output'
end
end
solid-result-2.0.0/lib/solid/result/ 0000775 0000000 0000000 00000000000 14606620746 0017350 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/_self.rb 0000664 0000000 0000000 00000011103 14606620746 0020761 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
attr_accessor :unknown, :event_logs
attr_reader :source, :data, :type_checker, :terminal
protected :source
private :unknown, :unknown=, :type_checker, :event_logs=
def self.config
Config.instance
end
def self.configuration(freeze: true)
yield(config)
freeze and config.freeze
end
def initialize(type:, value:, source: nil, expectations: nil, terminal: nil)
data = Data.new(kind, type, value)
@type_checker = Contract.evaluate(data, expectations)
@source = source
@terminal = kind == :failure || (terminal && !IgnoredTypes.include?(type))
@data = data
self.unknown = true
self.event_logs = EventLogs::Tracking::EMPTY
EventLogs.tracking.record(self)
end
def terminal?
terminal
end
def type
data.type
end
def value
data.value
end
def type?(arg)
type_checker.allow!(arg.to_sym) == type
end
def success?(_type = nil)
raise Error::NotImplemented
end
def failure?(_type = nil)
raise Error::NotImplemented
end
def value_or(&_block)
raise Error::NotImplemented
end
def on(*types, &block)
raise Error::MissingTypeArgument if types.empty?
tap { known(block) if type_checker.allow?(types) }
end
def on_success(*types, &block)
tap { known(block) if type_checker.allow_success?(types) && success? }
end
def on_failure(*types, &block)
tap { known(block) if type_checker.allow_failure?(types) && failure? }
end
def on_unknown
tap { yield(value, type) if unknown }
end
def and_then(method_name = nil, injected_value = nil, &block)
return self if terminal?
method_name && block and raise ::ArgumentError, 'method_name and block are mutually exclusive'
method_name ? call_and_then_source_method(method_name, injected_value) : call_and_then_block(block)
end
def and_then!(source, injected_value = nil, _call: nil)
raise Error::CallableAndThenDisabled unless Config.instance.feature.enabled?(:and_then!)
return self if terminal?
call_and_then_callable!(source, value: value, injected_value: injected_value, method_name: _call)
end
def handle
handler = Handler.new(self, type_checker: type_checker)
yield handler
handler.send(:outcome)
end
def ==(other)
self.class == other.class && type == other.type && value == other.value
end
def hash
[self.class, type, value].hash
end
def inspect
format('#<%s type=%p value=%p>', class_name: self.class.name, type: type, value: value)
end
def deconstruct
[type, value]
end
TYPE_AND_VALUE = %i[type value].freeze
def deconstruct_keys(keys)
output = TYPE_AND_VALUE.each_with_object({}) do |key, hash|
hash[key] = send(key) if keys.include?(key)
end
output.empty? ? value : output
end
def method_missing(name, *args, &block)
name.end_with?('?') ? is?(name.to_s.chomp('?')) : super
end
def respond_to_missing?(name, include_private = false)
name.end_with?('?') || super
end
alias is? type?
alias eql? ==
alias on_type on
private
def kind
:unknown
end
def known(block)
self.unknown = false
block.call(value, type)
end
def call_and_then_source_method(method_name, injected_value)
method = source.method(method_name)
EventLogs.tracking.record_and_then(method, injected_value) do
result = call_and_then_source_method!(method, injected_value)
ensure_result_object(result, origin: :method)
end
end
def call_and_then_source_method!(method, injected_value)
case method.arity
when 0 then source.send(method.name)
when 1 then source.send(method.name, value)
when 2 then source.send(method.name, value, injected_value)
else raise Error::InvalidSourceMethodArity.build(source: source, method: method, max_arity: 2)
end
end
def call_and_then_block(block)
EventLogs.tracking.record_and_then(:block, nil) do
result = call_and_then_block!(block)
ensure_result_object(result, origin: :block)
end
end
def call_and_then_block!(block)
block.call(value)
end
def call_and_then_callable!(source, value:, injected_value:, method_name:)
CallableAndThen::Caller.call(source, value: value, injected_value: injected_value, method_name: method_name)
end
def ensure_result_object(result, origin:)
raise Error::UnexpectedOutcome.build(outcome: result, origin: origin) unless result.is_a?(::Solid::Result)
return result if result.source.equal?(source)
raise Error::InvalidResultSource.build(given_result: result, expected_source: source)
end
end
solid-result-2.0.0/lib/solid/result/callable_and_then.rb 0000664 0000000 0000000 00000000345 14606620746 0023276 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module CallableAndThen
require_relative 'callable_and_then/error'
require_relative 'callable_and_then/config'
require_relative 'callable_and_then/caller'
end
end
solid-result-2.0.0/lib/solid/result/callable_and_then/ 0000775 0000000 0000000 00000000000 14606620746 0022747 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/callable_and_then/caller.rb 0000664 0000000 0000000 00000003173 14606620746 0024542 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class CallableAndThen::Caller
def self.call(source, value:, injected_value:, method_name:)
method = callable_method(source, method_name)
EventLogs.tracking.record_and_then(method, injected_value) do
result =
if source.is_a?(::Proc)
call_proc!(source, value, injected_value)
else
call_method!(source, method, value, injected_value)
end
ensure_result_object(source, value, result)
end
end
def self.call_proc!(source, value, injected_value)
case source.arity
when 1 then source.call(value)
when 2 then source.call(value, injected_value)
else raise CallableAndThen::Error::InvalidArity.build(source: source, method: :call, arity: '1..2')
end
end
def self.call_method!(source, method, value, injected_value)
case method.arity
when 1 then source.send(method.name, value)
when 2 then source.send(method.name, value, injected_value)
else raise CallableAndThen::Error::InvalidArity.build(source: source, method: method.name, arity: '1..2')
end
end
def self.callable_method(source, method_name)
source.method(method_name || Config.instance.and_then!.default_method_name_to_call)
end
def self.ensure_result_object(source, _value, result)
return result if result.is_a?(::Solid::Result)
raise Error::UnexpectedOutcome.build(outcome: result, origin: source)
end
private_class_method :new, :allocate
private_class_method :call_proc!, :call_method!, :callable_method, :ensure_result_object
end
end
solid-result-2.0.0/lib/solid/result/callable_and_then/config.rb 0000664 0000000 0000000 00000000463 14606620746 0024544 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class CallableAndThen::Config
attr_accessor :default_method_name_to_call
def initialize
self.default_method_name_to_call = :call
end
def options
{ default_method_name_to_call: default_method_name_to_call }
end
end
end
solid-result-2.0.0/lib/solid/result/callable_and_then/error.rb 0000664 0000000 0000000 00000000437 14606620746 0024431 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class CallableAndThen::Error < Error
class InvalidArity < self
def self.build(source:, method:, arity:)
new("Invalid arity for #{source.class}##{method} method. Expected arity: #{arity}")
end
end
end
end
solid-result-2.0.0/lib/solid/result/config.rb 0000664 0000000 0000000 00000002567 14606620746 0021154 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require_relative 'config/options'
require_relative 'config/switcher'
require_relative 'config/switchers/addons'
require_relative 'config/switchers/constant_aliases'
require_relative 'config/switchers/features'
require_relative 'config/switchers/pattern_matching'
class Solid::Result
class Config
attr_reader :addon, :feature, :constant_alias, :pattern_matching
def initialize
@addon = Addons.switcher
@feature = Features.switcher
@constant_alias = ConstantAliases.switcher
@pattern_matching = PatternMatching.switcher
@and_then_ = CallableAndThen::Config.new
end
def event_logs
EventLogs::Config.instance
end
def and_then!
@and_then_
end
def freeze
addon.freeze
feature.freeze
constant_alias.freeze
pattern_matching.freeze
and_then!.freeze
event_logs.freeze
super
end
def options
{
addon: addon,
feature: feature,
constant_alias: constant_alias,
pattern_matching: pattern_matching
}
end
def to_h
options.transform_values(&:to_h)
end
def inspect
"#<#{self.class.name} " \
"options=#{options.keys.sort.inspect} " \
"and_then!=#{and_then!.options.inspect}>"
end
@instance = new
singleton_class.send(:attr_reader, :instance)
end
end
solid-result-2.0.0/lib/solid/result/config/ 0000775 0000000 0000000 00000000000 14606620746 0020615 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/config/options.rb 0000664 0000000 0000000 00000001210 14606620746 0022627 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Config
module Options
def self.with_defaults(all_flags, config)
all_flags ||= {}
default_flags = Config.instance.to_h.fetch(config)
config_flags = all_flags.fetch(config, {})
default_flags.merge(config_flags).slice(*default_flags.keys)
end
def self.select(all_flags, config:, from:)
with_defaults(all_flags, config)
.filter_map { |name, truthy| [name, from[name]] if truthy }
.to_h
end
def self.addon(map:, from:)
select(map, config: :addon, from: from)
end
end
end
end
solid-result-2.0.0/lib/solid/result/config/switcher.rb 0000664 0000000 0000000 00000003360 14606620746 0022774 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Config
class Switcher
attr_reader :_options, :_affects, :listener
private :_options, :_affects, :listener
def initialize(options:, listener: nil)
@_options = options.transform_values { _1.fetch(:default) }
@_affects = options.transform_values { _1.fetch(:affects) }
@listener = listener
end
def inspect
"#<#{self.class.name} options=#{_options.inspect}>"
end
def freeze
_options.freeze
super
end
def to_h
_options.dup
end
def options
_affects.to_h { |name, affects| [name, { enabled: _options[name], affects: affects }] }
end
def enabled?(name)
_options[name] || false
end
def enable!(*names)
set_many(names, to: true)
end
def disable!(*names)
set_many(names, to: false)
end
private
def set_many(names, to:)
require_option!(names)
names.each do |name|
set_one(name, to)
listener&.call(name, to)
end
options.slice(*names)
end
def set_one(name, boolean)
validate_option!(name)
_options[name] = boolean
end
def require_option!(names)
raise ::ArgumentError, "One or more options required. #{available_options_message}" if names.empty?
end
def validate_option!(name)
return if _options.key?(name)
raise ::ArgumentError, "Invalid option: #{name.inspect}. #{available_options_message}"
end
def available_options_message
"Available options: #{_options.keys.map(&:inspect).join(', ')}"
end
end
private_constant :Switcher
end
end
solid-result-2.0.0/lib/solid/result/config/switchers/ 0000775 0000000 0000000 00000000000 14606620746 0022630 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/config/switchers/addons.rb 0000664 0000000 0000000 00000001046 14606620746 0024426 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Config
module Addons
AFFECTS = %w[
Solid::Result.mixin
Solid::Output.mixin
Solid::Result::Expectations.mixin
Solid::Output::Expectations.mixin
].freeze
OPTIONS = {
continue: { default: false, affects: AFFECTS },
given: { default: true, affects: AFFECTS }
}.transform_values!(&:freeze).freeze
def self.switcher
Switcher.new(options: OPTIONS)
end
end
private_constant :Addons
end
end
solid-result-2.0.0/lib/solid/result/config/switchers/constant_aliases.rb 0000664 0000000 0000000 00000001620 14606620746 0026506 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Config
module ConstantAliases
MAPPING = {
'Result' => { target: ::Object, name: :Result, value: ::Solid::Result }
}.transform_values!(&:freeze).freeze
OPTIONS = MAPPING.to_h do |option_name, mapping|
affects = mapping.fetch(:target).name.freeze
[option_name, { default: false, affects: [affects].freeze }]
end.freeze
Listener = ->(option_name, bool) do
mapping = MAPPING.fetch(option_name)
target, name, value = mapping.fetch_values(:target, :name, :value)
defined = target.const_defined?(name, false)
bool ? defined || target.const_set(name, value) : defined && target.send(:remove_const, name)
end
def self.switcher
Switcher.new(options: OPTIONS, listener: Listener)
end
end
private_constant :ConstantAliases
end
end
solid-result-2.0.0/lib/solid/result/config/switchers/features.rb 0000664 0000000 0000000 00000001604 14606620746 0024774 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Config
module Features
OPTIONS = {
expectations: {
default: true,
affects: %w[Solid::Result::Expectations Solid::Output::Expectations]
},
event_logs: {
default: true,
affects: %w[Solid::Result Solid::Output Solid::Result::Expectations Solid::Output::Expectations]
},
and_then!: {
default: false,
affects: %w[Solid::Result Solid::Output Solid::Result::Expectations Solid::Output::Expectations]
}
}.transform_values!(&:freeze).freeze
Listener = ->(option_name, _bool) do
Thread.current[EventLogs::THREAD_VAR_NAME] = nil if option_name == :event_logs
end
def self.switcher
Switcher.new(options: OPTIONS, listener: Listener)
end
end
private_constant :Features
end
end
solid-result-2.0.0/lib/solid/result/config/switchers/pattern_matching.rb 0000664 0000000 0000000 00000000667 14606620746 0026515 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Config
module PatternMatching
OPTIONS = {
nil_as_valid_value_checking: {
default: false,
affects: %w[Solid::Result::Expectations Solid::Output::Expectations]
}
}.transform_values!(&:freeze).freeze
def self.switcher
Switcher.new(options: OPTIONS)
end
end
private_constant :PatternMatching
end
end
solid-result-2.0.0/lib/solid/result/contract.rb 0000664 0000000 0000000 00000001557 14606620746 0021522 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::Contract
require_relative 'contract/error'
require_relative 'contract/type_checker'
require_relative 'contract/interface'
require_relative 'contract/evaluator'
require_relative 'contract/disabled'
require_relative 'contract/for_types'
require_relative 'contract/for_types_and_values'
NONE = Evaluator.new(Disabled, Disabled).freeze
def self.evaluate(data, contract)
contract ||= NONE
contract.type_and_value!(data)
TypeChecker.new(data.type, expectations: contract)
end
ToEnsure = ->(spec, config) do
return Disabled if spec.nil?
spec.is_a?(::Hash) ? ForTypesAndValues.new(spec, config) : ForTypes.new(Array(spec))
end
def self.new(success:, failure:, config:)
Evaluator.new(ToEnsure[success, config], ToEnsure[failure, config])
end
private_constant :ToEnsure
end
solid-result-2.0.0/lib/solid/result/contract/ 0000775 0000000 0000000 00000000000 14606620746 0021165 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/contract/disabled.rb 0000664 0000000 0000000 00000000564 14606620746 0023266 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module Contract::Disabled
extend Contract::Interface
EMPTY_SET = ::Set.new.freeze
def self.allowed_types
EMPTY_SET
end
def self.type?(_type)
true
end
def self.type!(type)
type
end
def self.type_and_value!(_data); end
private_constant :EMPTY_SET
end
end
solid-result-2.0.0/lib/solid/result/contract/error.rb 0000664 0000000 0000000 00000001001 14606620746 0022633 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result::Contract::Error < Solid::Result::Error
class UnexpectedType < self
def self.build(type:, allowed_types:)
new("type :#{type} is not allowed. Allowed types: #{allowed_types.map(&:inspect).join(', ')}")
end
end
class UnexpectedValue < self
def self.build(type:, value:, cause: nil)
cause_message = " (#{cause.message})" if cause
new("value #{value.inspect} is not allowed for :#{type} type#{cause_message}")
end
end
end
solid-result-2.0.0/lib/solid/result/contract/evaluator.rb 0000664 0000000 0000000 00000002060 14606620746 0023512 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Contract::Evaluator
include Contract::Interface
attr_reader :allowed_types, :success, :failure
def initialize(success, failure)
@success = success
@failure = failure
@allowed_types = (success.allowed_types | failure.allowed_types).freeze
end
def type?(type)
success_disabled = success == Contract::Disabled
failure_disabled = failure == Contract::Disabled
return Contract::Disabled.type?(type) if success_disabled && failure_disabled
(!success_disabled && success.type?(type)) || (!failure_disabled && failure.type?(type))
end
def type!(type)
return type if type?(type)
raise Contract::Error::UnexpectedType.build(type: type, allowed_types: allowed_types)
end
def type_and_value!(data)
self.for(data).type_and_value!(data)
end
private
def for(data)
case data.kind
when :unknown then Contract::Disabled
when :success then success
else failure
end
end
end
end
solid-result-2.0.0/lib/solid/result/contract/for_types.rb 0000664 0000000 0000000 00000001075 14606620746 0023527 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Contract::ForTypes
include Contract::Interface
attr_reader :allowed_types
def initialize(types)
@allowed_types = Array(types).map(&:to_sym).to_set.freeze
end
def type?(type)
IgnoredTypes.include?(type) || allowed_types.member?(type)
end
def type!(type)
return type if type?(type)
raise Contract::Error::UnexpectedType.build(type: type, allowed_types: allowed_types)
end
def type_and_value!(data)
type!(data.type)
nil
end
end
end
solid-result-2.0.0/lib/solid/result/contract/for_types_and_values.rb 0000664 0000000 0000000 00000002313 14606620746 0025724 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Contract::ForTypesAndValues
include Contract::Interface
def initialize(types_and_values, config)
@nil_as_valid_value_checking =
Config::Options
.with_defaults(config, :pattern_matching)
.fetch(:nil_as_valid_value_checking)
@types_and_values = types_and_values.transform_keys(&:to_sym)
@types_contract = Contract::ForTypes.new(@types_and_values.keys)
end
def allowed_types
@types_contract.allowed_types
end
def type?(type)
@types_contract.type?(type)
end
def type!(type)
@types_contract.type!(type)
end
def type_and_value!(data)
type, value = data.type, data.value
return value if IgnoredTypes.include?(type)
value_checking = @types_and_values[type!(type)]
checking_result = value_checking === value
return value if checking_result || (checking_result.nil? && @nil_as_valid_value_checking)
raise Contract::Error::UnexpectedValue.build(type: type, value: value)
rescue ::NoMatchingPatternError => e
raise Contract::Error::UnexpectedValue.build(type: data.type, value: data.value, cause: e)
end
end
end
solid-result-2.0.0/lib/solid/result/contract/interface.rb 0000664 0000000 0000000 00000000544 14606620746 0023455 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module Contract::Interface
def allowed_types
raise Error::NotImplemented
end
def type?(_type)
raise Error::NotImplemented
end
def type!(_type)
raise Error::NotImplemented
end
def type_and_value!(_data)
raise Error::NotImplemented
end
end
end
solid-result-2.0.0/lib/solid/result/contract/type_checker.rb 0000664 0000000 0000000 00000001514 14606620746 0024160 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::Contract
class TypeChecker
attr_reader :result_type, :expectations
def initialize(result_type, expectations:)
@result_type = result_type
@expectations = expectations
end
def allow!(type)
expectations.type!(type)
end
def allow?(types)
validate(types, expected: expectations, allow_empty: false)
end
def allow_success?(types)
validate(types, expected: expectations.success, allow_empty: true)
end
def allow_failure?(types)
validate(types, expected: expectations.failure, allow_empty: true)
end
private
def validate(types, expected:, allow_empty:)
(allow_empty && types.empty?) || types.any? { |type| expected.type!(type) == result_type }
end
end
private_constant :TypeChecker
end
solid-result-2.0.0/lib/solid/result/data.rb 0000664 0000000 0000000 00000001137 14606620746 0020610 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Data
attr_reader :kind, :type, :value
def initialize(kind, type, value)
@kind = kind
@type = type.to_sym
@value = value
end
def to_h
{ kind: kind, type: type, value: value }
end
def to_a
[kind, type, value]
end
def inspect
format(
'#<%s kind=%p type=%p value=%p>',
class_name: self.class.name, kind: kind, type: type, value: value
)
end
alias to_ary to_a
alias to_hash to_h
end
private_constant :Data
end
solid-result-2.0.0/lib/solid/result/error.rb 0000664 0000000 0000000 00000003272 14606620746 0021032 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result::Error < StandardError
def self.build(**_kargs)
new
end
class NotImplemented < self
end
class MissingTypeArgument < self
def initialize(_message = nil)
super('A type (argument) is required to invoke the #on/#on_type method')
end
end
class UnexpectedOutcome < self
def self.build(outcome:, origin:, expected: nil)
expected ||= 'Solid::Result::Success or Solid::Result::Failure'
new("Unexpected outcome: #{outcome.inspect}. The #{origin} must return this object wrapped by #{expected}")
end
end
class InvalidResultSource < self
def self.build(given_result:, expected_source:)
message =
"You cannot call #and_then and return a result that does not belong to the same source!\n" \
"Expected source: #{expected_source.inspect}\n" \
"Given source: #{given_result.send(:source).inspect}\n" \
"Given result: #{given_result.inspect}"
new(message)
end
end
class InvalidSourceMethodArity < self
def self.build(source:, method:, max_arity:)
new("#{source.class}##{method.name} has unsupported arity (#{method.arity}). Expected 0..#{max_arity}")
end
end
class UnhandledTypes < self
def self.build(types:)
source = types.size == 1 ? 'This was' : 'These were'
new("You must handle all cases. #{source} not handled: #{types.map(&:inspect).join(', ')}")
end
end
class CallableAndThenDisabled < self
def initialize(_message = nil)
super(
'You cannot use #and_then! as the feature is disabled. ' \
'Please use Solid::Result.config.feature.enable!(:and_then!) to enable it.'
)
end
end
end
solid-result-2.0.0/lib/solid/result/event_logs.rb 0000664 0000000 0000000 00000001322 14606620746 0022040 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module EventLogs
require_relative 'event_logs/listener'
require_relative 'event_logs/listeners'
require_relative 'event_logs/config'
require_relative 'event_logs/tree'
require_relative 'event_logs/tracking'
THREAD_VAR_NAME = :solid_result_event_logs_tracking
EnsureResult = ->(result) do
return result if result.is_a?(::Solid::Result)
raise Error::UnexpectedOutcome.build(outcome: result, origin: :event_logs)
end
def self.tracking
Thread.current[THREAD_VAR_NAME] ||= Tracking.instance
end
end
def self.event_logs(name: nil, desc: nil, &block)
EventLogs.tracking.exec(name, desc, &block)
end
end
solid-result-2.0.0/lib/solid/result/event_logs/ 0000775 0000000 0000000 00000000000 14606620746 0021515 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/event_logs/config.rb 0000664 0000000 0000000 00000001137 14606620746 0023311 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::EventLogs
class Config
attr_reader :listener, :trace_id
def initialize
@trace_id = -> {}
@listener = Listener::Null.new
end
def listener=(arg)
Listener.kind?(arg) or raise ::ArgumentError, "#{arg.inspect} must be a #{Listener}"
@listener = arg
end
def trace_id=(arg)
raise ::ArgumentError, 'must be a lambda with arity 0' unless arg.is_a?(::Proc) && arg.lambda? && arg.arity.zero?
@trace_id = arg
end
@instance = new
singleton_class.send(:attr_reader, :instance)
end
end
solid-result-2.0.0/lib/solid/result/event_logs/listener.rb 0000664 0000000 0000000 00000001562 14606620746 0023673 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::EventLogs
module Listener
module ClassMethods
def around_event_logs?
false
end
def around_and_then?
false
end
end
def self.included(base)
base.extend(ClassMethods)
end
def self.extended(base)
base.extend(ClassMethods)
end
def self.kind?(arg)
(arg.is_a?(::Class) && arg < self) || (arg.is_a?(::Module) && arg.is_a?(self)) || arg.is_a?(Listeners::Chain)
end
def on_start(scope:); end
def around_event_logs(scope:)
yield
end
def around_and_then(scope:, and_then:)
yield
end
def on_record(record:); end
def on_finish(event_logs:); end
def before_interruption(exception:, event_logs:); end
end
module Listener::Null
extend Listener
def self.new
self
end
end
end
solid-result-2.0.0/lib/solid/result/event_logs/listeners.rb 0000664 0000000 0000000 00000005177 14606620746 0024064 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::EventLogs
class Listeners
class Chain
include Listener
attr_reader :listeners
def initialize(list)
if list.empty? || list.any? { !Listener.kind?(_1) }
raise ArgumentError, "listeners must be a list of #{Listener}"
end
around_and_then = list.select(&:around_and_then?)
around_event_logs = list.select(&:around_event_logs?)
raise ArgumentError, 'only one listener can have around_and_then? == true' if around_and_then.size > 1
raise ArgumentError, 'only one listener can have around_event_logs? == true' if around_event_logs.size > 1
@listeners = { list: list, around_and_then: around_and_then[0], around_event_logs: around_event_logs[0] }
end
def new
list, around_and_then, around_event_logs = listeners[:list], nil, nil
instances = list.map do |item|
instance = item.new
around_and_then = instance if listener?(:around_and_then, instance)
around_event_logs = instance if listener?(:around_event_logs, instance)
instance
end
list.one? ? list[0].new : Listeners.send(:new, instances, around_and_then, around_event_logs)
end
private
def listener?(name, obj)
listener = listeners[name]
!listener.nil? && (obj.is_a?(listener) || obj == listener)
end
end
private_class_method :new
def self.[](*listeners)
Chain.new(listeners)
end
attr_reader :listeners, :around_and_then_listener, :around_event_logs_listener
private :listeners, :around_and_then_listener, :around_event_logs_listener
def initialize(listeners, around_and_then_listener, around_event_logs_listener)
@listeners = listeners
@around_and_then_listener = around_and_then_listener || Listener::Null
@around_event_logs_listener = around_event_logs_listener || Listener::Null
end
def on_start(scope:)
listeners.each { _1.on_start(scope: scope) }
end
def around_event_logs(scope:, &block)
around_event_logs_listener.around_event_logs(scope: scope, &block)
end
def around_and_then(scope:, and_then:, &block)
around_and_then_listener.around_and_then(scope: scope, and_then: and_then, &block)
end
def on_record(record:)
listeners.each { _1.on_record(record: record) }
end
def on_finish(event_logs:)
listeners.each { _1.on_finish(event_logs: event_logs) }
end
def before_interruption(exception:, event_logs:)
listeners.each { _1.before_interruption(exception: exception, event_logs: event_logs) }
end
end
end
solid-result-2.0.0/lib/solid/result/event_logs/tracking.rb 0000664 0000000 0000000 00000001313 14606620746 0023642 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module EventLogs
module Tracking
require_relative 'tracking/enabled'
require_relative 'tracking/disabled'
VERSION = 1
EMPTY_ARRAY = [].freeze
EMPTY_HASH = {}.freeze
EMPTY_TREE = Tree.new(nil).freeze
EMPTY_IDS = { tree: EMPTY_ARRAY, matrix: EMPTY_HASH, level_parent: EMPTY_HASH }.freeze
EMPTY = {
version: VERSION,
records: EMPTY_ARRAY,
metadata: { duration: 0, ids: EMPTY_IDS, trace_id: nil }.freeze
}.freeze
def self.instance
::Solid::Result::Config.instance.feature.enabled?(:event_logs) ? Tracking::Enabled.new : Tracking::Disabled
end
end
end
end
solid-result-2.0.0/lib/solid/result/event_logs/tracking/ 0000775 0000000 0000000 00000000000 14606620746 0023317 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/event_logs/tracking/disabled.rb 0000664 0000000 0000000 00000000411 14606620746 0025407 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::EventLogs
module Tracking::Disabled
def self.exec(_name, _desc)
EnsureResult[yield]
end
def self.record(result); end
def self.record_and_then(_type, _data)
yield
end
end
end
solid-result-2.0.0/lib/solid/result/event_logs/tracking/enabled.rb 0000664 0000000 0000000 00000007267 14606620746 0025252 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Result::EventLogs
class Tracking::Enabled
attr_accessor :tree, :records, :root_started_at, :listener
private :tree, :tree=, :records, :records=, :root_started_at, :root_started_at=, :listener, :listener=
def exec(name, desc)
event_log_node, scope = start(name, desc)
result = nil
listener.around_event_logs(scope: scope) do
result = EnsureResult[yield]
end
tree.move_to_root! if event_log_node.root?
finish(result)
result
rescue ::Exception => e
err!(e, event_log_node)
end
def err!(exception, event_log_node)
if event_log_node.root?
listener.before_interruption(exception: exception, event_logs: map_event_logs)
reset!
end
raise exception
end
def reset!
self.tree = Tracking::EMPTY_TREE
end
def record(result)
return if tree.frozen?
track(result, time: ::Time.now.getutc)
end
def record_and_then(type_arg, arg)
return yield if tree.frozen?
type = type_arg.instance_of?(::Method) ? :method : type_arg
current_and_then = { type: type, arg: arg }
current_and_then[:method_name] = type_arg.name if type == :method
tree.current.value[1] = current_and_then
scope, and_then = tree.current_value
result = nil
listener.around_and_then(scope: scope, and_then: and_then) { result = yield }
result
end
def reset_and_then!
return if tree.frozen?
tree.current.value[1] = Tracking::EMPTY_HASH
end
private
def start(name, desc)
name_and_desc = [name, desc]
tree.frozen? ? root_start(name_and_desc) : tree.insert!(name_and_desc)
scope = tree.current.value[0]
listener.on_start(scope: scope)
[tree.current, scope]
end
def finish(result)
node = tree.current
tree.move_up!
return unless node.root?
event_logs = map_event_logs
result.send(:event_logs=, event_logs)
listener.on_finish(event_logs: event_logs)
reset!
end
TreeNodeValueNormalizer = ->(id, (nam, des)) { [{ id: id, name: nam, desc: des }, Tracking::EMPTY_HASH] }
def root_start(name_and_desc)
self.root_started_at = now_in_milliseconds
self.listener = build_listener
self.records = []
self.tree = Tree.new(name_and_desc, normalizer: TreeNodeValueNormalizer)
end
def track(result, time:)
record = track_record(result, time)
records << record
listener.on_record(record: record)
record
end
def track_record(result, time)
result_data = result.data.to_h
result_data[:source] = result.send(:source)
root, = tree.root_value
parent, = tree.parent_value
current, and_then = tree.current_value
{ root: root, parent: parent, current: current, result: result_data, and_then: and_then, time: time }
end
def now_in_milliseconds
::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
end
def map_event_logs
duration = (now_in_milliseconds - root_started_at)
trace_id = Config.instance.trace_id.call
ids = { tree: tree.ids, matrix: tree.ids_matrix, level_parent: tree.ids_level_parent }
metadata = { duration: duration, trace_id: trace_id, ids: ids }
{ version: Tracking::VERSION, records: records, metadata: metadata }
end
def build_listener
Config.instance.listener.new
rescue ::StandardError => e
err = "#{e.message} (#{e.class}); Backtrace: #{e.backtrace&.join(', ')}"
warn("Fallback to #{Listener::Null} because registered listener raised an exception: #{err}")
Listener::Null.new
end
end
end
solid-result-2.0.0/lib/solid/result/event_logs/tree.rb 0000664 0000000 0000000 00000005356 14606620746 0023012 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module EventLogs
class Tree
class Node
attr_reader :id, :value, :parent, :normalizer, :children
def initialize(value, parent:, id:, normalizer:)
@normalizer = normalizer
@id = id
@value = normalizer.call(id, value)
@parent = parent
@children = []
end
def insert(value, id:)
node = self.class.new(value, parent: self, id: id, normalizer: normalizer)
@children << node
node
end
def root?
parent.nil?
end
def leaf?
children.empty?
end
def node?
!leaf?
end
def inspect
"#<#{self.class.name} id=#{id} children.size=#{children.size}>"
end
end
attr_reader :size, :root, :current
def initialize(value, normalizer: ->(_id, val) { val })
@size = 0
@root = Node.new(value, parent: nil, id: size, normalizer: normalizer)
@current = root
end
def root_value
root.value
end
def parent_value
current.parent&.value || root_value
end
def current_value
current.value
end
def insert(value)
@size += 1
current.insert(value, id: size)
end
def insert!(value)
move_to! insert(value)
end
def move_to!(node)
tap { @current = node }
end
def move_up!(level = 1)
tap { level.times { move_to!(current.parent || root) } }
end
def move_down!(level = 1, index: -1)
tap { level.times { current.children[index].then { |child| move_to!(child) if child } } }
end
def move_to_root!
move_to!(root)
end
Ids = ->(node) { [node.id, node.children.map(&Ids)] }
def ids
Ids[root]
end
def ids_list
ids.flatten
end
IdsMatrix = ->(tree, row, col, memo, previous) do
last_row = previous[0]
tree.each_with_index do |node, index|
row = [(index + 1), last_row].max
id, leaf = node
memo[id] = previous == [row, col] ? [row, col + 1] : [row, col]
previous = memo[id]
IdsMatrix[leaf, row, col + 1, memo, previous]
end
end
def ids_matrix
current = [0, 0]
memo = { 0 => current }
IdsMatrix[ids[1], 1, 1, memo, current]
memo
end
IdsLevelParent = ->((id, node), parent = 0, level = 0, memo = {}) do
memo[id] = [level, parent]
node.each { |leaf| IdsLevelParent[leaf, id, level + 1, memo] }
memo
end
def ids_level_parent
IdsLevelParent[ids]
end
end
end
end
solid-result-2.0.0/lib/solid/result/expectations.rb 0000664 0000000 0000000 00000003751 14606620746 0022411 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Expectations
require_relative 'expectations/mixin'
def self.mixin(**options)
return mixin!(**options) if Config.instance.feature.enabled?(:expectations)
result_factory_without_expectations.mixin(**options.slice(:config))
end
def self.mixin!(success: nil, failure: nil, config: nil)
addons = mixin_module::Addons.options(config)
mod = mixin_module::Factory.module!
mod.const_set(:Result, new(success: success, failure: failure, config: config).freeze)
mod.module_eval(mixin_module::Methods.to_eval(addons), __FILE__, __LINE__ + 1)
mod.send(:include, *addons.values) unless addons.empty?
mod
end
def self.mixin_module
Mixin
end
def self.result_factory_without_expectations
::Solid::Result
end
def self.new(...)
return result_factory_without_expectations unless Config.instance.feature.enabled?(:expectations)
instance = allocate
instance.send(:initialize, ...)
instance
end
private_class_method :mixin!, :mixin_module, :result_factory_without_expectations
def initialize(source: nil, contract: nil, terminal: nil, **options)
@terminal = terminal
@source = source
@contract = contract if contract.is_a?(Contract::Evaluator)
@contract ||= Contract.new(
success: options[:success],
failure: options[:failure],
config: options[:config]
).freeze
end
def Success(type, value = nil)
_ResultAs(Success, type, value)
end
def Failure(type, value = nil)
_ResultAs(Failure, type, value)
end
def with(source:, terminal: nil)
self.class.new(source: source, terminal: terminal, contract: contract)
end
private
def _ResultAs(kind_class, type, value)
kind_class.new(type: type, value: value, source: source, expectations: contract, terminal: terminal)
end
attr_reader :source, :terminal, :contract
end
end
solid-result-2.0.0/lib/solid/result/expectations/ 0000775 0000000 0000000 00000000000 14606620746 0022056 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/expectations/mixin.rb 0000664 0000000 0000000 00000002464 14606620746 0023535 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module Expectations::Mixin
module Factory
def self.module!
::Module.new do
def self.included(base); base.const_set(:ResultExpectationsMixin, self); end
def self.extended(base); base.const_set(:ResultExpectationsMixin, self); end
end
end
end
module Methods
BASE = <<~RUBY
def Success(...)
_Result.Success(...)
end
def Failure(...)
_Result.Failure(...)
end
RUBY
FACTORY = <<~RUBY
private def _Result
@_Result ||= Result.with(source: self, terminal: %s)
end
RUBY
def self.to_eval(addons)
terminal = addons.key?(:continue) ? 'true' : 'nil'
"#{BASE}\n#{format(FACTORY, terminal: terminal)}"
end
end
module Addons
module Continue
private def Continue(value)
_Result.Success(IgnoredTypes::CONTINUE, value)
end
end
module Given
private def Given(value)
_Result.Success(IgnoredTypes::GIVEN, value)
end
end
OPTIONS = { continue: Continue, given: Given }.freeze
def self.options(config_flags)
Config::Options.addon(map: config_flags, from: OPTIONS)
end
end
end
end
solid-result-2.0.0/lib/solid/result/failure.rb 0000664 0000000 0000000 00000000310 14606620746 0021316 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Failure < self
include ::Solid::Failure
end
def self.Failure(type, value = nil)
Failure.new(type: type, value: value)
end
end
solid-result-2.0.0/lib/solid/result/handler.rb 0000664 0000000 0000000 00000002262 14606620746 0021314 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Handler
require_relative 'handler/allowed_types'
UNDEFINED = ::Object.new
def initialize(result, type_checker:)
@allowed_types = AllowedTypes.new(type_checker)
@outcome = UNDEFINED
@result = result
end
def [](*types, &block)
raise Error::MissingTypeArgument if types.empty?
self.outcome = block if allowed_types.allow?(types)
end
def success(*types, &block)
self.outcome = block if allowed_types.allow_success?(types) && result.success?
end
def failure(*types, &block)
self.outcome = block if allowed_types.allow_failure?(types) && result.failure?
end
def unknown(&block)
self.outcome = block unless outcome?
end
alias type []
private
attr_reader :result, :allowed_types
def outcome?
@outcome != UNDEFINED
end
def outcome=(block)
@outcome = block.call(result.value, result.type) unless outcome?
end
def outcome
allowed_types.all_checked? or raise Error::UnhandledTypes.build(types: allowed_types.unchecked)
@outcome if outcome?
end
end
private_constant :Handler
end
solid-result-2.0.0/lib/solid/result/handler/ 0000775 0000000 0000000 00000000000 14606620746 0020765 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/lib/solid/result/handler/allowed_types.rb 0000664 0000000 0000000 00000001722 14606620746 0024167 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Handler
class AllowedTypes
attr_reader :unchecked, :type_checker
def initialize(type_checker)
@type_checker = type_checker
@expectations = type_checker.expectations
@unchecked = @expectations.allowed_types.dup
end
def allow?(types)
check!(types, type_checker.allow?(types))
end
def allow_success?(types)
unchecked.subtract(@expectations.success.allowed_types) if types.empty?
check!(types, type_checker.allow_success?(types))
end
def allow_failure?(types)
unchecked.subtract(@expectations.failure.allowed_types) if types.empty?
check!(types, type_checker.allow_failure?(types))
end
def all_checked?
unchecked.empty?
end
private
def check!(types, checked)
unchecked.subtract(types) unless all_checked?
checked
end
end
end
end
solid-result-2.0.0/lib/solid/result/ignored_types.rb 0000664 0000000 0000000 00000000345 14606620746 0022552 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module IgnoredTypes
LIST = ::Set[
GIVEN = :_given_,
CONTINUE = :_continue_
].freeze
def self.include?(type)
LIST.member?(type)
end
end
end
solid-result-2.0.0/lib/solid/result/mixin.rb 0000664 0000000 0000000 00000003247 14606620746 0021027 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
module Mixin
module Factory
def self.module!
::Module.new do
def self.included(base); base.const_set(:ResultMixin, self); end
def self.extended(base); base.const_set(:ResultMixin, self); end
end
end
end
module Methods
def Success(type, value = nil)
_ResultAs(Success, type, value)
end
def Failure(type, value = nil)
_ResultAs(Failure, type, value)
end
private def _ResultAs(kind_class, type, value, terminal: nil)
kind_class.new(type: type, value: value, source: self, terminal: terminal)
end
end
module Addons
module Continue
def Success(type, value = nil)
_ResultAs(Success, type, value, terminal: true)
end
private def Continue(value)
_ResultAs(Success, IgnoredTypes::CONTINUE, value)
end
end
module Given
private def Given(value)
_ResultAs(Success, IgnoredTypes::GIVEN, value)
end
end
OPTIONS = { continue: Continue, given: Given }.freeze
def self.options(config_flags)
Config::Options.addon(map: config_flags, from: OPTIONS)
end
end
end
def self.mixin(config: nil)
addons = mixin_module::Addons.options(config)
mod = mixin_module::Factory.module!
mod.send(:include, mixin_module::Methods)
mod.const_set(:Result, result_factory)
mod.send(:include, *addons.values) unless addons.empty?
mod
end
def self.mixin_module
Mixin
end
def self.result_factory
::Solid::Result
end
private_class_method :mixin_module, :result_factory
end
solid-result-2.0.0/lib/solid/result/success.rb 0000664 0000000 0000000 00000000310 14606620746 0021337 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Result
class Success < self
include ::Solid::Success
end
def self.Success(type, value = nil)
Success.new(type: type, value: value)
end
end
solid-result-2.0.0/lib/solid/result/version.rb 0000664 0000000 0000000 00000000133 14606620746 0021357 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
class Result
VERSION = '2.0.0'
end
end
solid-result-2.0.0/lib/solid/success.rb 0000664 0000000 0000000 00000000456 14606620746 0020034 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
module Success
def success?(type = nil)
type.nil? || type_checker.allow_success?([type])
end
def failure?(_type = nil)
false
end
def value_or
value
end
private
def kind
:success
end
end
end
solid-result-2.0.0/sig/ 0000775 0000000 0000000 00000000000 14606620746 0014734 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/sig/solid/ 0000775 0000000 0000000 00000000000 14606620746 0016046 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/sig/solid/failure.rbs 0000664 0000000 0000000 00000000456 14606620746 0020212 0 ustar 00root root 0000000 0000000 module Solid
module Failure
def success?: (?Symbol type) -> bool
def failure?: (?Symbol type) -> bool
def value_or: { (untyped) -> untyped } -> untyped
def value: -> untyped
private
def kind: -> Symbol
def type_checker: -> Solid::Result::Contract::TypeChecker
end
end
solid-result-2.0.0/sig/solid/output.rbs 0000664 0000000 0000000 00000010366 14606620746 0020124 0 ustar 00root root 0000000 0000000 class Solid::Output < Solid::Result
EXPECTED_OUTCOME: String
SourceMethodArity: ^(Method) -> Integer
attr_reader memo: Hash[Symbol, untyped]
def initialize: (
type: Symbol,
value: untyped,
?source: untyped,
?expectations: Solid::Result::Contract::Evaluator,
?terminal: bool
) -> void
def and_then: (?Symbol, **untyped) ?{ (Hash[Symbol, untyped]) -> untyped } -> untyped
def and_then!: (untyped, **untyped) -> untyped
private
def call_and_then_source_method: (Symbol, Hash[Symbol, untyped]) -> Solid::Output
def call_and_then_callable!: (untyped, value: untyped, injected_value: untyped, method_name: (Symbol | nil)) -> Solid::Output
def ensure_result_object: (untyped, origin: Symbol) -> Solid::Output
def raise_unexpected_outcome_error: (Solid::Output | untyped, Symbol) -> void
end
class Solid::Output
class Error < Solid::Result::Error
class InvalidExposure < Solid::Output::Error
end
end
end
class Solid::Output
class Success < Solid::Output
include Solid::Success
FetchValues: Proc
def and_expose: (Symbol, Array[Symbol], terminal: bool) -> Solid::Output::Success
end
def self.Success: (Symbol, **untyped) -> Solid::Output::Success
end
module Solid::Output::CallableAndThen
class Caller < Solid::Result::CallableAndThen::Caller
module KeyArgs
def self.parameters?: (untyped) -> bool
def self.invalid_arity: (untyped, Symbol) -> Solid::Result::CallableAndThen::Error::InvalidArity
end
def self.call: (
untyped source,
value: untyped,
injected_value: untyped,
method_name: (Symbol | nil),
) -> Solid::Output
private
def self.call_proc!: (
untyped source,
Hash[Symbol, untyped] value,
nil injected_value
) -> Solid::Output
def self.call_method!: (
untyped source,
Method method,
Hash[Symbol, untyped] value,
nil injected_value
) -> Solid::Output
def self.callable_method: (
untyped source,
(Symbol | nil) method_name
) -> ::Method
def self.ensure_result_object: (
untyped source,
untyped value,
Solid::Output result
) -> Solid::Output
def self.expected_result_object: () -> singleton(Solid::Output)
def self.expected_outcome: () -> String
end
end
class Solid::Output
class Failure < Solid::Output
include Solid::Failure
def and_expose: (Symbol, Array[Symbol], **untyped) -> Solid::Output::Failure
end
def self.Failure: (Symbol, **untyped) -> Solid::Output::Failure
end
class Solid::Output
module Mixin
Factory: singleton(Solid::Result::Mixin::Factory)
module Methods
def Success: (Symbol, **untyped) -> Solid::Output::Success
def Failure: (Symbol, **untyped) -> Solid::Output::Failure
private
def _ResultAs: (singleton(Solid::Output), Symbol, untyped, ?terminal: bool) -> untyped
end
module Addons
module Continue
include Solid::Output::Mixin::Methods
private
def Continue: (**untyped) -> Solid::Output::Success
end
module Given
include Solid::Output::Mixin::Methods
private
def Given: (*untyped) -> Solid::Output::Success
end
OPTIONS: Hash[Symbol, Module]
def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
end
end
def self.mixin_module: -> singleton(Solid::Output::Mixin)
def self.result_factory: -> singleton(Solid::Output)
end
class Solid::Output::Expectations < Solid::Result::Expectations
def self.mixin_module: -> singleton(Solid::Output::Expectations::Mixin)
def self.result_factory_without_expectations: -> singleton(Solid::Result)
def Success: (Symbol, **untyped) -> Solid::Output::Success
def Failure: (Symbol, **untyped) -> Solid::Output::Failure
end
module Solid::Output::Expectations::Mixin
Methods: singleton(Solid::Result::Expectations::Mixin::Methods)
Factory: singleton(Solid::Result::Expectations::Mixin::Factory)
module Addons
module Continue
private def Continue: (**untyped) -> Solid::Output::Success
end
module Given
private def Given: (*untyped) -> Solid::Output::Success
end
OPTIONS: Hash[Symbol, Module]
def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
end
end
solid-result-2.0.0/sig/solid/result.rbs 0000664 0000000 0000000 00000005275 14606620746 0020105 0 ustar 00root root 0000000 0000000 class Solid::Result
private attr_accessor unknown: bool
private attr_writer event_logs: Hash[Symbol, untyped]
private attr_reader type_checker: Solid::Result::Contract::TypeChecker
attr_reader data: Solid::Result::Data
attr_reader source: untyped
attr_reader terminal: bool
attr_reader event_logs: Hash[Symbol, untyped]
def self.config: -> Solid::Result::Config
def self.configuration: (freeze: bool) { (Solid::Result::Config) -> void } -> (bool | Solid::Result::Config)
def self.event_logs: (name: untyped, desc: untyped) { () -> untyped } -> Solid::Result
def initialize: (
type: Symbol,
value: untyped,
?source: untyped,
?expectations: Solid::Result::Contract::Evaluator,
?terminal: bool
) -> void
def type: -> Symbol
def value: -> untyped
def type?: (Symbol | String) -> bool
def terminal?: -> bool
def success?: (?Symbol type) -> bool
def failure?: (?Symbol type) -> bool
def value_or: { () -> untyped } -> untyped
def on: (*Symbol) { (untyped, Symbol) -> void } -> Solid::Result
def on_success: (*Symbol) { (untyped, Symbol) -> void } -> Solid::Result
def on_failure: (*Symbol) { (untyped, Symbol) -> void } -> Solid::Result
def on_unknown: () { (untyped, Symbol) -> void } -> Solid::Result
def and_then: (?Symbol method_name, ?untyped injected_value) ?{ (untyped) -> untyped } -> untyped
def and_then!: (untyped, ?untyped injected_value, _call: (Symbol | nil)) -> untyped
def handle: () { (Solid::Result::Handler) -> void } -> untyped
def ==: (untyped) -> bool
def hash: -> Integer
def inspect: -> String
def deconstruct: -> [Symbol, [Symbol, untyped]]
def deconstruct_keys: (Array[Symbol]) -> Hash[Symbol, Hash[Symbol, untyped]]
TYPE_AND_VALUE: Array[Symbol]
def method_missing: (Symbol, *untyped) { (untyped) -> untyped } -> untyped
alias is? type?
alias eql? ==
alias on_type on
private
def kind: -> Symbol
def known: (Proc) -> untyped
def call_and_then_source_method: (Symbol, untyped) -> Solid::Result
def call_and_then_source_method!: (untyped, untyped) -> Solid::Result
def call_and_then_block: (untyped) -> Solid::Result
def call_and_then_block!: (untyped) -> Solid::Result
def call_and_then_callable!: (untyped, value: untyped, injected_value: untyped, method_name: (Symbol | nil)) -> Solid::Result
def ensure_result_object: (untyped, origin: Symbol) -> Solid::Result
end
class Solid::Result
class Success < Solid::Result
include Solid::Success
end
def self.Success: (Symbol type, ?untyped value) -> Solid::Result::Success
end
class Solid::Result
class Failure < Solid::Result
include Solid::Failure
end
def self.Failure: (Symbol type, ?untyped value) -> Solid::Result::Failure
end
solid-result-2.0.0/sig/solid/result/ 0000775 0000000 0000000 00000000000 14606620746 0017364 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/sig/solid/result/callable_and_then.rbs 0000664 0000000 0000000 00000002264 14606620746 0023477 0 ustar 00root root 0000000 0000000 module Solid::Result::CallableAndThen
class Config
attr_accessor default_method_name_to_call: Symbol
def initialize: -> void
def options: () -> Hash[Symbol, untyped]
end
class Error < Solid::Result::Error
end
class Error::InvalidArity < Error
def self.build: (
source: untyped,
method: Symbol,
arity: String
) -> Error::InvalidArity
end
class Caller
def self.call: (
untyped source,
value: untyped,
injected_value: untyped,
method_name: (Symbol | nil)
) -> Solid::Result
private
def self.call_proc!: (
untyped source,
untyped value,
untyped injected_value
) -> Solid::Result
def self.call_method!: (
untyped source,
Method method,
untyped value,
untyped injected_value
) -> Solid::Result
def self.callable_method: (
untyped source,
(Symbol | nil) method_name
) -> ::Method
def self.ensure_result_object: (
untyped source,
untyped value,
Solid::Result result
) -> Solid::Result
def self.expected_result_object: () -> singleton(Solid::Result)
def self.expected_outcome: () -> String
end
end
solid-result-2.0.0/sig/solid/result/config.rbs 0000664 0000000 0000000 00000005516 14606620746 0021350 0 ustar 00root root 0000000 0000000 class Solid::Result::Config
ADDON: Hash[Symbol, Hash[Symbol, untyped]]
FEATURE: Hash[Symbol, Hash[Symbol, untyped]]
PATTERN_MATCHING: Hash[Symbol, Hash[Symbol, untyped]]
attr_reader addon: Solid::Result::Config::Switcher
attr_reader feature: Solid::Result::Config::Switcher
attr_reader constant_alias: Solid::Result::Config::Switcher
attr_reader pattern_matching: Solid::Result::Config::Switcher
def self.instance: -> Solid::Result::Config
def initialize: -> void
def and_then!: () -> Solid::Result::CallableAndThen::Config
def event_logs: () -> Solid::Result::EventLogs::Config
def freeze: -> Solid::Result::Config
def options: -> Hash[Symbol, Solid::Result::Config::Switcher]
def to_h: -> Hash[Symbol, Hash[Symbol | String, bool]]
end
module Solid::Result::Config::Options
def self.with_defaults: (
Hash[Symbol, Hash[Symbol, bool]],
Symbol
) -> Hash[Symbol, bool]
def self.select: (
Hash[Symbol, Hash[Symbol, bool]],
config: Symbol,
from: Hash[Symbol, untyped]
) -> Hash[Symbol, untyped]
def self.addon: (
map: Hash[Symbol, Hash[Symbol, bool]],
from: Hash[Symbol, Module]
) -> Hash[Symbol, Module]
end
class Solid::Result::Config::Switcher
private attr_reader _affects: Hash[Symbol | String, Array[String]]
private attr_reader _options: Hash[Symbol | String, bool]
private attr_reader listener: Proc
def initialize: (
options: Hash[Symbol | String, Hash[Symbol, untyped]],
?listener: Proc
) -> void
def freeze: -> Solid::Result::Config::Switcher
def to_h: -> Hash[Symbol | String, bool]
def options: -> Hash[Symbol | String, Hash[Symbol, untyped]]
def enabled?: (Symbol | String) -> bool
def enable!: (*(Symbol | String)) -> Hash[Symbol | String, Hash[Symbol, untyped]]
def disable!: (*(Symbol | String)) -> Hash[Symbol | String, Hash[Symbol, untyped]]
private
def set_many: (Array[Symbol | String], to: bool) -> Hash[Symbol | String, Hash[Symbol, untyped]]
def set_one: (Symbol | String, bool) -> void
def require_option!: (Array[Symbol | String]) -> void
def validate_option!: (Symbol | String) -> void
def available_options_message: -> String
end
module Solid::Result::Config::Addons
AFFECTS: Array[String]
OPTIONS: Hash[String, Hash[Symbol, untyped]]
def self.switcher: -> Solid::Result::Config::Switcher
end
module Solid::Result::Config::ConstantAliases
MAPPING: Hash[String, Hash[Symbol, untyped]]
OPTIONS: Hash[String, Hash[Symbol, untyped]]
Listener: Proc
def self.switcher: -> Solid::Result::Config::Switcher
end
module Solid::Result::Config::Features
OPTIONS: Hash[String, Hash[Symbol, untyped]]
Listener: Proc
def self.switcher: -> Solid::Result::Config::Switcher
end
module Solid::Result::Config::PatternMatching
OPTIONS: Hash[String, Hash[Symbol, untyped]]
def self.switcher: -> Solid::Result::Config::Switcher
end
solid-result-2.0.0/sig/solid/result/contract.rbs 0000664 0000000 0000000 00000005416 14606620746 0021717 0 ustar 00root root 0000000 0000000 module Solid::Result::Contract
NONE: Solid::Result::Contract::Evaluator
def self.evaluate: (
Solid::Result::Data,
Solid::Result::Contract::Evaluator
) -> Solid::Result::Contract::TypeChecker
ToEnsure: ^(Hash[Symbol, untyped] | Array[Symbol], Hash[Symbol, Hash[Symbol, bool]])
-> Solid::Result::Contract::Interface
def self.new: (
success: Hash[Symbol, untyped] | Array[Symbol],
failure: Hash[Symbol, untyped] | Array[Symbol],
config: Hash[Symbol, Hash[Symbol, bool]]
) -> Solid::Result::Contract::Evaluator
end
module Solid::Result::Contract
class TypeChecker
attr_reader result_type: Symbol
attr_reader expectations: Solid::Result::Contract::Evaluator
def initialize: (
Symbol,
expectations: Solid::Result::Contract::Evaluator
) -> void
def allow!: (Symbol) -> Symbol
def allow?: (Array[Symbol]) -> bool
def allow_success?: (Array[Symbol]) -> bool
def allow_failure?: (Array[Symbol]) -> bool
private
def validate: (
Array[Symbol],
expected: Solid::Result::Contract::Interface,
allow_empty: bool
) -> bool
end
end
class Solid::Result::Contract::Error < Solid::Result::Error
class UnexpectedType < Solid::Result::Contract::Error
def self.build: (type: Symbol, allowed_types: Set[Symbol])
-> Solid::Result::Contract::Error::UnexpectedType
end
class UnexpectedValue < Solid::Result::Contract::Error
def self.build: (type: Symbol, value: untyped, ?cause: Exception)
-> Solid::Result::Contract::Error::UnexpectedValue
end
end
module Solid::Result::Contract
module Interface
def ==: (Solid::Result::Contract::Interface) -> bool
def allowed_types: -> Set[Symbol]
def type?: (Symbol) -> bool
def type!: (Symbol) -> Symbol
def type_and_value!: (Solid::Result::Data) -> void
def !=: (untyped) -> bool
end
end
module Solid::Result::Contract
module Disabled
extend Interface
EMPTY_SET: Set[Symbol]
end
end
module Solid::Result::Contract
class ForTypes
include Interface
def initialize: (Array[Symbol]) -> void
end
end
module Solid::Result::Contract
class ForTypesAndValues
include Interface
def initialize: (
Hash[Symbol, untyped],
Hash[Symbol, Hash[Symbol, bool]]
) -> void
private
def nil_as_valid_value_checking?: -> bool
end
end
module Solid::Result::Contract
class Evaluator
include Interface
attr_reader allowed_types: Set[Symbol]
attr_reader success: Solid::Result::Contract::Interface
attr_reader failure: Solid::Result::Contract::Interface
def initialize: (
Solid::Result::Contract::Interface,
Solid::Result::Contract::Interface
) -> void
private
def for: (Solid::Result::Data) -> Solid::Result::Contract::Interface
end
end
solid-result-2.0.0/sig/solid/result/data.rbs 0000664 0000000 0000000 00000000541 14606620746 0021005 0 ustar 00root root 0000000 0000000 class Solid::Result
class Data
attr_reader kind: Symbol
attr_reader type: Symbol
attr_reader value: untyped
attr_reader to_h: Hash[Symbol, untyped]
attr_reader to_a: [Symbol, Symbol, untyped]
def initialize: (Symbol, Symbol, untyped) -> void
def inspect: -> String
alias to_ary to_a
alias to_hash to_h
end
end
solid-result-2.0.0/sig/solid/result/error.rbs 0000664 0000000 0000000 00000002012 14606620746 0021220 0 ustar 00root root 0000000 0000000 class Solid::Result
class Error < StandardError
def self.build: (**untyped) -> Solid::Result::Error
class NotImplemented < Solid::Result::Error
end
class MissingTypeArgument < Solid::Result::Error
end
class UnexpectedOutcome < Solid::Result::Error
def self.build: (outcome: untyped, origin: Symbol, ?expected: String)
-> Solid::Result::Error::UnexpectedOutcome
end
class InvalidResultSource < Solid::Result::Error
def self.build: (given_result: Solid::Result, expected_source: untyped)
-> Solid::Result::Error::InvalidResultSource
end
class InvalidSourceMethodArity < Solid::Result::Error
def self.build: (source: untyped, method: Method, max_arity: Integer)
-> Solid::Result::Error::InvalidSourceMethodArity
end
class UnhandledTypes < Solid::Result::Error
def self.build: (types: Set[Symbol])
-> Solid::Result::Error::UnhandledTypes
end
class CallableAndThenDisabled < Solid::Result::Error
end
end
end
solid-result-2.0.0/sig/solid/result/event_logs.rbs 0000664 0000000 0000000 00000012773 14606620746 0022253 0 ustar 00root root 0000000 0000000 class Solid::Result
module EventLogs
module Listener
module ClassMethods
def around_and_then?: () -> bool
def around_event_logs?: () -> bool
end
extend ClassMethods
def around_event_logs: (scope: Hash[Symbol, untyped]) { () -> untyped } -> untyped
def on_start: (scope: Hash[Symbol, untyped]) -> untyped
def around_and_then: (scope: Hash[Symbol, untyped], and_then: Hash[Symbol, untyped]) { () -> untyped } -> untyped
def on_record: (record: Hash[Symbol, untyped] ) -> untyped
def on_finish: (event_logs: Hash[Symbol, untyped] ) -> untyped
def before_interruption: (exception: ::Exception, event_logs: Hash[Symbol, untyped]) -> untyped
end
class Listeners
class Chain
include Listener
attr_reader listeners: Hash[Symbol, untyped]
def initialize: (Array[untyped]) -> void
def new: () -> Listeners
private
def listener?: (untyped, untyped) -> bool
end
def self.[]: (*untyped) -> Chain
private attr_reader listeners: Array[Listener]
private attr_reader around_and_then_listener: untyped
private attr_reader around_event_logs_listener: untyped
def initialize: (Array[Listener], untyped, untyped) -> void
def around_event_logs: (scope: Hash[Symbol, untyped]) { () -> untyped } -> untyped
def on_start: (scope: Hash[Symbol, untyped]) -> untyped
def around_and_then: (scope: Hash[Symbol, untyped], and_then: Hash[Symbol, untyped]) { () -> untyped } -> untyped
def on_record: (record: Hash[Symbol, untyped] ) -> untyped
def on_finish: (event_logs: Hash[Symbol, untyped] ) -> untyped
def before_interruption: (exception: ::Exception, event_logs: Hash[Symbol, untyped]) -> untyped
end
module Listener::Null
extend Listener
def self.new: () -> untyped
end
class Config
attr_reader listener: untyped
attr_reader trace_id: ::Proc
def self.instance: -> Config
def initialize: -> void
def listener=: (Listener) -> void
def trace_id=: (::Proc) -> void
end
class Tree
class Node
attr_reader id: Integer
attr_reader value: untyped
attr_reader parent: (Node | nil)
attr_reader normalizer: ^(Integer, Array[untyped]) -> untyped
attr_reader children: Array[Node]
def initialize: (
untyped value,
parent: (Node | nil),
id: Integer,
normalizer: ^(Integer, Array[untyped]) -> untyped
) -> void
def insert: (untyped, id: Integer) -> Node
def root?: () -> bool
def leaf?: () -> bool
def node?: () -> bool
def inspect: () -> String
end
attr_reader size: Integer
attr_reader root: Node
attr_reader current: Node
def initialize: (untyped, ?normalizer: ^(Integer, Array[untyped]) -> untyped) -> void
def root_value: () -> untyped
def parent_value: () -> untyped
def current_value: () -> untyped
def insert: (untyped) -> Node
def insert!: (untyped) -> Tree
def move_to!: (Node) -> Tree
def move_up!: (?Integer level) -> Tree
def move_down!: (?Integer level) -> Tree
def move_to_root!: () -> Tree
Ids: ^(Node) -> Array[untyped]
IdsMatrix: ::Proc
IdsLevelParent: ::Proc
def ids: () -> Array[untyped]
def ids_list: () -> Array[Integer]
def ids_matrix: () -> untyped
def ids_level_parent: () -> untyped
end
module Tracking
EMPTY_ARRAY: Array[untyped]
EMPTY_HASH: Hash[untyped, untyped]
EMPTY_TREE: EventLogs::Tree
EMPTY_IDS: Hash[untyped, untyped]
VERSION: Integer
EMPTY: Hash[Symbol, untyped]
class Enabled
private attr_accessor tree: EventLogs::Tree
private attr_accessor records: Array[Hash[Symbol, untyped]]
private attr_accessor listener: untyped
private attr_accessor root_started_at: Integer
def exec: (untyped, untyped) { () -> untyped } -> untyped
def err!: (::Exception, untyped) -> void
def reset!: () -> void
def record: (Solid::Result) -> void
def record_and_then: ((untyped), untyped) { () -> untyped } -> untyped
def reset_and_then!: () -> void
private
def start: (String, String) -> [EventLogs::Tree::Node, Hash[Symbol, untyped]]
def finish: (untyped) -> untyped
TreeNodeValueNormalizer: ^(Integer, Array[untyped]) -> untyped
def root_start: (Array[untyped]) -> void
def track: (Solid::Result, time: Time) -> void
def track_record: (Solid::Result, Time) -> Hash[Symbol, untyped]
def now_in_milliseconds: () -> Integer
def map_event_logs: () -> Hash[Symbol, untyped]
def build_listener: () -> Listener
end
module Disabled
def self.exec: (untyped, untyped) { () -> untyped } -> untyped
def self.err!: (::Exception) -> void
def self.reset!: () -> void
def self.record: (Solid::Result) -> void
def self.record_and_then: ((untyped), untyped) { () -> Solid::Result } -> Solid::Result
def self.reset_and_then!: () -> void
private
def self.start: (String, String) -> void
def self.finish: (untyped) -> untyped
end
def self.instance: () -> (Enabled | singleton(Disabled))
end
THREAD_VAR_NAME: Symbol
EnsureResult: ^(untyped) -> Solid::Result
def self.tracking: () -> (Tracking::Enabled | singleton(Tracking::Disabled))
end
end
solid-result-2.0.0/sig/solid/result/expectations.rbs 0000664 0000000 0000000 00000003414 14606620746 0022604 0 ustar 00root root 0000000 0000000 class Solid::Result::Expectations
def self.mixin: (
?config: Hash[Symbol, Hash[Symbol, bool]],
?success: Hash[Symbol, untyped] | Array[Symbol],
?failure: Hash[Symbol, untyped] | Array[Symbol]
) -> Module
def self.mixin!: (
?config: Hash[Symbol, Hash[Symbol, bool]],
?success: Hash[Symbol, untyped] | Array[Symbol],
?failure: Hash[Symbol, untyped] | Array[Symbol]
) -> Module
def self.mixin_module: -> singleton(Solid::Result::Expectations::Mixin)
def self.result_factory_without_expectations: -> singleton(Solid::Result)
def self.new: (
?source: untyped,
?contract: Solid::Result::Contract::Evaluator,
?terminal: bool,
**untyped
) -> (Solid::Result::Expectations | untyped)
def initialize: (
?source: untyped,
?contract: Solid::Result::Contract::Evaluator,
?terminal: bool,
**untyped
) -> void
def Success: (Symbol, ?untyped) -> Solid::Result::Success
def Failure: (Symbol, ?untyped) -> Solid::Result::Failure
def with: (source: untyped) -> Solid::Result::Expectations
private
def _ResultAs: (singleton(Solid::Result), Symbol, untyped) -> untyped
attr_reader source: untyped
attr_reader contract: Solid::Result::Contract::Evaluator
attr_reader terminal: bool
end
module Solid::Result::Expectations::Mixin
module Factory
def self.module!: -> Module
end
module Methods
BASE: String
FACTORY: String
def self.to_eval: (Hash[Symbol, untyped]) -> String
end
module Addons
module Continue
private def Continue: (untyped) -> Solid::Result::Success
end
module Given
private def Given: (untyped) -> Solid::Result::Success
end
OPTIONS: Hash[Symbol, Module]
def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
end
end
solid-result-2.0.0/sig/solid/result/handler.rbs 0000664 0000000 0000000 00000002172 14606620746 0021513 0 ustar 00root root 0000000 0000000 class Solid::Result
class Handler
UNDEFINED: Object
def initialize: (
Solid::Result,
type_checker: Solid::Result::Contract::TypeChecker
) -> void
def []: (*Symbol) { (untyped, Symbol) -> void } -> untyped
def failure: (*Symbol) { (untyped, Symbol) -> void } -> untyped
def success: (*Symbol) { (untyped, Symbol) -> void } -> untyped
def unknown: () { (untyped, Symbol) -> void } -> untyped
alias type []
private
attr_reader result: Solid::Result
attr_reader allowed_types: Solid::Result::Handler::AllowedTypes
def outcome?: -> bool
def outcome=: (Proc) -> void
def outcome: -> untyped
end
end
class Solid::Result::Handler
class AllowedTypes
attr_reader unchecked: Set[Symbol]
attr_reader type_checker: Solid::Result::Contract::TypeChecker
def initialize: (
Solid::Result::Contract::TypeChecker
) -> void
def allow?: (Array[Symbol]) -> bool
def allow_success?: (Array[Symbol]) -> bool
def allow_failure?: (Array[Symbol]) -> bool
def all_checked?: -> bool
private
def check!: (Array[Symbol], bool) -> bool
end
end
solid-result-2.0.0/sig/solid/result/ignored_types.rbs 0000664 0000000 0000000 00000000244 14606620746 0022747 0 ustar 00root root 0000000 0000000 class Solid::Result
module IgnoredTypes
LIST: ::Set[::Symbol]
GIVEN: ::Symbol
CONTINUE: ::Symbol
def self.include?: (::Symbol) -> bool
end
end
solid-result-2.0.0/sig/solid/result/mixin.rbs 0000664 0000000 0000000 00000002013 14606620746 0021214 0 ustar 00root root 0000000 0000000 class Solid::Result
module Mixin
module Factory
def self.module!: -> Module
end
module Methods
def Success: (Symbol type, ?untyped value) -> Solid::Result::Success
def Failure: (Symbol type, ?untyped value) -> Solid::Result::Failure
private
def _ResultAs: (singleton(Solid::Result), Symbol, untyped, ?terminal: bool) -> untyped
end
module Addons
module Continue
include Solid::Result::Mixin::Methods
private
def Continue: (untyped) -> Solid::Result::Success
end
module Given
include Solid::Result::Mixin::Methods
private
def Given: (untyped) -> Solid::Result::Success
end
OPTIONS: Hash[Symbol, Module]
def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
end
end
def self.mixin: (?config: Hash[Symbol, Hash[Symbol, bool]]) -> Module
def self.mixin_module: -> singleton(Solid::Result::Mixin)
def self.result_factory: -> singleton(Solid::Result)
end
solid-result-2.0.0/sig/solid/result/version.rbs 0000664 0000000 0000000 00000000072 14606620746 0021560 0 ustar 00root root 0000000 0000000 module Solid
class Result
VERSION: String
end
end
solid-result-2.0.0/sig/solid/success.rbs 0000664 0000000 0000000 00000000447 14606620746 0020233 0 ustar 00root root 0000000 0000000 module Solid
module Success
def success?: (?Symbol type) -> bool
def failure?: (?Symbol type) -> bool
def value_or: { () -> untyped } -> untyped
def value: -> untyped
private
def kind: -> Symbol
def type_checker: -> Solid::Result::Contract::TypeChecker
end
end
solid-result-2.0.0/solid-result.gemspec 0000664 0000000 0000000 00000003257 14606620746 0020154 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require_relative 'lib/solid/result/version'
Gem::Specification.new do |spec|
spec.name = 'solid-result'
spec.version = Solid::Result::VERSION
spec.authors = ['Rodrigo Serradura']
spec.email = ['rodrigo.serradura@gmail.com']
'Unleash a pragmatic and observable use of Result Pattern and Railway-Oriented Programming in Ruby.'
.then do |summary|
spec.summary = summary
spec.description = summary
end
spec.homepage = 'https://github.com/solid-process/solid-result'
spec.license = 'MIT'
spec.required_ruby_version = '>= 2.7.0'
spec.metadata['allowed_push_host'] = 'https://rubygems.org'
spec.metadata['homepage_uri'] = spec.homepage
spec.metadata['source_code_uri'] = 'https://github.com/solid-process/solid-result'
spec.metadata['changelog_uri'] = 'https://github.com/solid-process/solid-result/blob/main/CHANGELOG.md'
# Specify which files should be added to the gem when it is released.
# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
spec.files = Dir.chdir(__dir__) do
`git ls-files -z`.split("\x0").reject do |f|
(File.expand_path(f) == __FILE__) ||
f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
end
end
spec.bindir = 'exe'
spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
spec.require_paths = ['lib']
# Uncomment to register a new dependency of your gem
# spec.add_dependency "example-gem", "~> 1.0"
# For more information and examples about making a new gem, check out our
# guide at: https://bundler.io/guides/creating_gem.html
spec.metadata['rubygems_mfa_required'] = 'true'
end
solid-result-2.0.0/test/ 0000775 0000000 0000000 00000000000 14606620746 0015131 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/ 0000775 0000000 0000000 00000000000 14606620746 0016243 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/ 0000775 0000000 0000000 00000000000 14606620746 0017603 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/addons/ 0000775 0000000 0000000 00000000000 14606620746 0021053 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/addons/continue/ 0000775 0000000 0000000 00000000000 14606620746 0022677 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/addons/continue/expectations_test.rb 0000664 0000000 0000000 00000024627 14606620746 0027004 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::AddonsContinueExpectationsTest < Minitest::Test
class DivideType
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :ok,
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Continue(number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **)
number2.zero? ? Failure(:err, 'arg2 must not be zero') : Continue()
end
def divide(number1:, number2:)
Success(:ok, number: number1 / number2)
end
end
class DivideTypes
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue(number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **)
number2.zero? ? Failure(:err, message: 'arg2 must not be zero') : Continue()
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
module DivideTypeAndValue
extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: {
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
},
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue(number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **)
return Failure(:division_by_zero, message: 'arg2 must not be zero') if number2.zero?
Continue()
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'method chaining using Continue' do
result1 = DivideType.new.call(10, 2)
result2 = DivideTypes.new.call(10, 2)
result3 = DivideTypeAndValue.call(10, 2)
assert result1.success?(:ok)
assert result2.success?(:division_completed)
assert result3.success?(:division_completed)
end
test 'type checking' do
success1 = DivideType.new.call(10, 2)
success2 = DivideTypes.new.call(10, 2)
success3 = DivideTypeAndValue.call(10, 2)
failure1 = DivideType.new.call('10', 0)
failure2 = DivideTypes.new.call('10', 0)
failure3 = DivideTypeAndValue.call('10', 0)
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { success1.success?(:division_completed) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { success2.success?(:ok) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { success3.success?(:ok) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { failure1.failure?(:invalid_arg) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { failure2.failure?(:err) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { failure3.failure?(:err) }
end
class InstanceFirstSuccessToTerminateTheStepChainAndThenBlock
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
def call
Success(:first)
.and_then { Continue(second: true) }
.and_then { Continue(third: true) }
end
end
class InstanceSecondSuccessToTerminateTheStepChainAndThenBlock
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
def call
Continue(first: true)
.and_then { Success(:second) }
.and_then { Continue(third: true) }
end
end
class InstanceThirdSuccessToTerminateTheStepChainAndThenBlock
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
def call
Continue(first: true)
.and_then { Continue(second: true) }
.and_then { Success(:third) }
end
end
module SingletonFirstSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
def call
Success(:first)
.and_then { Continue(second: true) }
.and_then { Continue(third: true) }
end
end
module SingletonSecondSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
def call
Continue(first: true)
.and_then { Success(:second) }
.and_then { Continue(third: true) }
end
end
module SingletonThirdSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
def call
Continue(first: true)
.and_then { Continue(second: true) }
.and_then { Success(:third) }
end
end
test 'the step chain termination (and_then block)' do
instance_result1 = InstanceFirstSuccessToTerminateTheStepChainAndThenBlock.new.call
instance_result2 = InstanceSecondSuccessToTerminateTheStepChainAndThenBlock.new.call
instance_result3 = InstanceThirdSuccessToTerminateTheStepChainAndThenBlock.new.call
singleton_result1 = SingletonFirstSuccessToTerminateTheStepChainAndThenBlock.call
singleton_result2 = SingletonSecondSuccessToTerminateTheStepChainAndThenBlock.call
singleton_result3 = SingletonThirdSuccessToTerminateTheStepChainAndThenBlock.call
assert(instance_result1.success?(:first) && instance_result1.terminal?)
assert(instance_result2.success?(:second) && instance_result2.terminal?)
assert(instance_result3.success?(:third) && instance_result3.terminal?)
assert(singleton_result1.success?(:first) && singleton_result1.terminal?)
assert(singleton_result2.success?(:second) && singleton_result2.terminal?)
assert(singleton_result3.success?(:third) && singleton_result3.terminal?)
end
class InstanceFirstSuccessToTerminateTheStepChainAndThenMethod
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Success(:first); end
def second_success; Continue(second: true); end
def third_success; Continue(third: true); end
end
class InstanceSecondSuccessToTerminateTheStepChainAndThenMethod
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(first: true); end
def second_success; Success(:second); end
def third_success; Continue(third: true); end
end
class InstanceThirdSuccessToTerminateTheStepChainAndThenMethod
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(first: true); end
def second_success; Continue(second: true); end
def third_success; Success(:third); end
end
module SingletonFirstSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Success(:first); end
def second_success; Continue(second: true); end
def third_success; Continue(third: true); end
end
module SingletonSecondSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(first: true); end
def second_success; Success(:second); end
def third_success; Continue(third: true); end
end
module SingletonThirdSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(first: true); end
def second_success; Continue(second: true); end
def third_success; Success(:third); end
end
test 'the step chain termination (and_then calling a method)' do
instance_result1 = InstanceFirstSuccessToTerminateTheStepChainAndThenMethod.new.call
instance_result2 = InstanceSecondSuccessToTerminateTheStepChainAndThenMethod.new.call
instance_result3 = InstanceThirdSuccessToTerminateTheStepChainAndThenMethod.new.call
assert(instance_result1.success?(:first) && instance_result1.terminal?)
assert(instance_result2.success?(:second) && instance_result2.terminal?)
assert(instance_result3.success?(:third) && instance_result3.terminal?)
end
end
solid-result-2.0.0/test/solid/output/addons/continue/instance_test.rb 0000664 0000000 0000000 00000011101 14606620746 0026061 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::AddonsContinueInstanceTest < Minitest::Test
class Divide
include Solid::Output.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue(number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **)
return Continue() unless number2.zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'method chaining using Continue' do
success = Divide.new.call(10, 2)
failure1 = Divide.new.call('10', 0)
failure2 = Divide.new.call(10, '2')
failure3 = Divide.new.call(10, 0)
assert_predicate success, :success?
assert_equal :division_completed, success.type
assert_equal({ number: 5 }, success.value)
assert_predicate failure1, :failure?
assert_equal :invalid_arg, failure1.type
assert_equal({ message: 'arg1 must be numeric' }, failure1.value)
assert_predicate failure2, :failure?
assert_equal :invalid_arg, failure2.type
assert_equal({ message: 'arg2 must be numeric' }, failure2.value)
assert_predicate failure3, :failure?
assert_equal :division_by_zero, failure3.type
assert_equal({ message: 'arg2 must not be zero' }, failure3.value)
end
class FirstSuccessToTerminateTheStepChainAndThenBlock
include Solid::Output.mixin(config: { addon: { continue: true } })
def call
Success(:first)
.and_then { Continue(second: true) }
.and_then { Continue(third: true) }
end
end
class SecondSuccessToTerminateTheStepChainAndThenBlock
include Solid::Output.mixin(config: { addon: { continue: true } })
def call
Continue(first: true)
.and_then { Success(:second) }
.and_then { Continue(third: true) }
end
end
class ThirdSuccessToTerminateTheStepChainAndThenBlock
include Solid::Output.mixin(config: { addon: { continue: true } })
def call
Continue(first: true)
.and_then { Continue(second: true) }
.and_then { Success(:third) }
end
end
test 'the step chain termination (and_then block)' do
result1 = FirstSuccessToTerminateTheStepChainAndThenBlock.new.call
result2 = SecondSuccessToTerminateTheStepChainAndThenBlock.new.call
result3 = ThirdSuccessToTerminateTheStepChainAndThenBlock.new.call
assert(result1.success?(:first) && result1.terminal?)
assert(result2.success?(:second) && result2.terminal?)
assert(result3.success?(:third) && result3.terminal?)
end
class FirstSuccessToTerminateTheStepChainAndThenMethod
include Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Success(:first); end
def second_success; Continue(second: true); end
def third_success; Continue(third: true); end
end
class SecondSuccessToTerminateTheStepChainAndThenMethod
include Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(first: true); end
def second_success; Success(:second); end
def third_success; Continue(third: true); end
end
class ThirdSuccessToTerminateTheStepChainAndThenMethod
include Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(first: true); end
def second_success; Continue(second: true); end
def third_success; Success(:third); end
end
test 'the step chain termination (and_then calling a method)' do
result1 = FirstSuccessToTerminateTheStepChainAndThenMethod.new.call
result2 = SecondSuccessToTerminateTheStepChainAndThenMethod.new.call
result3 = ThirdSuccessToTerminateTheStepChainAndThenMethod.new.call
assert(result1.success?(:first) && result1.terminal?)
assert(result2.success?(:second) && result2.terminal?)
assert(result3.success?(:third) && result3.terminal?)
end
end
solid-result-2.0.0/test/solid/output/addons/continue/singleton_test.rb 0000664 0000000 0000000 00000011173 14606620746 0026270 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::AddonsContinueSingletonTest < Minitest::Test
module Divide
extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide, extra_division: 2)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue(number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **)
return Continue() unless number2.zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:, extra_division:)
Success(:division_completed, number: (number1 / number2) / extra_division)
end
end
test 'method chaining using Continue' do
success = Divide.call(20, 2)
failure1 = Divide.call('10', 0)
failure2 = Divide.call(10, '2')
failure3 = Divide.call(10, 0)
assert_predicate success, :success?
assert_equal :division_completed, success.type
assert_equal({ number: 5 }, success.value)
assert_predicate failure1, :failure?
assert_equal :invalid_arg, failure1.type
assert_equal({ message: 'arg1 must be numeric' }, failure1.value)
assert_predicate failure2, :failure?
assert_equal :invalid_arg, failure2.type
assert_equal({ message: 'arg2 must be numeric' }, failure2.value)
assert_predicate failure3, :failure?
assert_equal :division_by_zero, failure3.type
assert_equal({ message: 'arg2 must not be zero' }, failure3.value)
end
module FirstSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
Success(:first)
.and_then { Continue(second: true) }
.and_then { Continue(third: true) }
end
end
module SecondSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
Continue(first: true)
.and_then { Success(:second) }
.and_then { Continue(third: true) }
end
end
module ThirdSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
Continue(first: true)
.and_then { Continue(second: true) }
.and_then { Success(:third) }
end
end
test 'the step chain termination (and_then block)' do
result1 = FirstSuccessToTerminateTheStepChainAndThenBlock.call
result2 = SecondSuccessToTerminateTheStepChainAndThenBlock.call
result3 = ThirdSuccessToTerminateTheStepChainAndThenBlock.call
assert(result1.success?(:first) && result1.terminal?)
assert(result2.success?(:second) && result2.terminal?)
assert(result3.success?(:third) && result3.terminal?)
end
module FirstSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Success(:first); end
def second_success; Continue(second: true); end
def third_success; Continue(third: true); end
end
module SecondSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(first: true); end
def second_success; Success(:second); end
def third_success; Continue(third: true); end
end
module ThirdSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(first: true); end
def second_success; Continue(second: true); end
def third_success; Success(:third); end
end
test 'the step chain termination (and_then calling a method)' do
result1 = FirstSuccessToTerminateTheStepChainAndThenMethod.call
result2 = SecondSuccessToTerminateTheStepChainAndThenMethod.call
result3 = ThirdSuccessToTerminateTheStepChainAndThenMethod.call
assert(result1.success?(:first) && result1.terminal?)
assert(result2.success?(:second) && result2.terminal?)
assert(result3.success?(:third) && result3.terminal?)
end
end
solid-result-2.0.0/test/solid/output/addons/given/ 0000775 0000000 0000000 00000000000 14606620746 0022163 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/addons/given/expectations_test.rb 0000664 0000000 0000000 00000006534 14606620746 0026265 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::AddonsGivenExpectationsTest < Minitest::Test
class DivideType
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :ok,
failure: :err
)
def call(arg1, arg2)
Given(number1: arg1, number2: arg2)
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(number1:, number2:)
number1.is_a?(::Numeric) or return Failure(:err, message: 'arg1 must be numeric')
number2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Continue()
end
def validate_non_zero(number2:, **)
number2.zero? ? Failure(:err, 'arg2 must not be zero') : Continue()
end
def divide(number1:, number2:)
Success(:ok, number: number1 / number2)
end
end
class DivideTypes
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
Given(number1: arg1, number2: arg2)
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(number1:, number2:)
number1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
number2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue()
end
def validate_non_zero(number2:, **)
number2.zero? ? Failure(:err, message: 'arg2 must not be zero') : Continue()
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
module DivideTypeAndValue
extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: {
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
},
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
Given(number1: arg1, number2: arg2)
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(number1:, number2:)
number1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
number2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue()
end
def validate_non_zero(number2:, **)
return Failure(:division_by_zero, message: 'arg2 must not be zero') if number2.zero?
Continue()
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'method chaining' do
result1 = DivideType.new.call(10, 2)
result2 = DivideTypes.new.call(10, 2)
result3 = DivideTypeAndValue.call(10, 2)
assert result1.success?(:ok)
assert result2.success?(:division_completed)
assert result3.success?(:division_completed)
end
end
solid-result-2.0.0/test/solid/output/addons/given/instance_test.rb 0000664 0000000 0000000 00000003331 14606620746 0025353 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::AddonsGivenInstanceTest < Minitest::Test
class Divide
include Solid::Output.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given(number1: arg1, number2: arg2)
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(number1:, number2:)
number1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
number2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue()
end
def validate_non_zero(number2:, **)
return Continue() unless number2.zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'method chaining using Continue' do
success = Divide.new.call(10, 2)
failure1 = Divide.new.call('10', 0)
failure2 = Divide.new.call(10, '2')
failure3 = Divide.new.call(10, 0)
assert_predicate success, :success?
assert_equal :division_completed, success.type
assert_equal({ number: 5 }, success.value)
assert_predicate failure1, :failure?
assert_equal :invalid_arg, failure1.type
assert_equal({ message: 'arg1 must be numeric' }, failure1.value)
assert_predicate failure2, :failure?
assert_equal :invalid_arg, failure2.type
assert_equal({ message: 'arg2 must be numeric' }, failure2.value)
assert_predicate failure3, :failure?
assert_equal :division_by_zero, failure3.type
assert_equal({ message: 'arg2 must not be zero' }, failure3.value)
end
end
solid-result-2.0.0/test/solid/output/addons/given/singleton_test.rb 0000664 0000000 0000000 00000003370 14606620746 0025554 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::AddonsGivenSingletonTest < Minitest::Test
module Divide
extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given(number1: arg1, number2: arg2)
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide, extra_division: 2)
end
private
def validate_numbers(number1:, number2:)
number1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
number2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue()
end
def validate_non_zero(number2:, **)
return Continue() unless number2.zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:, extra_division:)
Success(:division_completed, number: (number1 / number2) / extra_division)
end
end
test 'method chaining' do
success = Divide.call(20, 2)
failure1 = Divide.call('10', 0)
failure2 = Divide.call(10, '2')
failure3 = Divide.call(10, 0)
assert_predicate success, :success?
assert_equal :division_completed, success.type
assert_equal({ number: 5 }, success.value)
assert_predicate failure1, :failure?
assert_equal :invalid_arg, failure1.type
assert_equal({ message: 'arg1 must be numeric' }, failure1.value)
assert_predicate failure2, :failure?
assert_equal :invalid_arg, failure2.type
assert_equal({ message: 'arg2 must be numeric' }, failure2.value)
assert_predicate failure3, :failure?
assert_equal :division_by_zero, failure3.type
assert_equal({ message: 'arg2 must not be zero' }, failure3.value)
end
end
solid-result-2.0.0/test/solid/output/and_expose/ 0000775 0000000 0000000 00000000000 14606620746 0021730 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/and_expose/all_values_test.rb 0000664 0000000 0000000 00000002264 14606620746 0025447 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndExposeAllValuesTest < Minitest::Test
class Divide
include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:divide, extra_division: 2)
.and_expose(:division_completed, %i[final_number extra_division number1 number2])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def divide(number1:, number2:, extra_division:)
Success(:division_completed, final_number: (number1 / number2) / extra_division)
end
end
test '#and_expose can expose all the values (accumulated or not)' do
result = Divide.new.call(12, 2)
assert result.success?(:division_completed)
assert_equal(
{
final_number: 3,
extra_division: 2,
number1: 12,
number2: 2
},
result.value
)
end
end
end
solid-result-2.0.0/test/solid/output/and_expose/argument_error_test.rb 0000664 0000000 0000000 00000002510 14606620746 0026345 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndExposeArgumentErrorTest < Minitest::Test
class NotAnArray
include Solid::Output.mixin
def call
Success(:ok, number: 1)
.and_expose(:ok, nil)
end
end
class EmptyArray
include Solid::Output.mixin
def call
Success(:ok, number: 1)
.and_expose(:ok, [])
end
end
class AnyKeyAreNotSymbol
include Solid::Output.mixin
def call
Success(:ok, number: 1)
.and_expose(:ok, [:number, 'number'])
end
end
test '#and_expose raises ArgumentError when keys is not an Array' do
err = assert_raises(ArgumentError) { NotAnArray.new.call }
assert_equal(
'keys must be an Array of Symbols',
err.message
)
end
test '#and_expose raises ArgumentError when keys is an empty Array' do
err = assert_raises(ArgumentError) { EmptyArray.new.call }
assert_equal(
'keys must be an Array of Symbols',
err.message
)
end
test '#and_expose raises ArgumentError when any key is not a Symbol' do
err = assert_raises(ArgumentError) { AnyKeyAreNotSymbol.new.call }
assert_equal(
'keys must be an Array of Symbols',
err.message
)
end
end
end
solid-result-2.0.0/test/solid/output/and_expose/expectations_test.rb 0000664 0000000 0000000 00000004461 14606620746 0026027 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputExpectationsTest < Minitest::Test
class Divide1
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: { division_completed: ->(value) { value[:final_number].is_a?(Numeric) } },
failure: { invalid_arg: ->(value) { value[:message].is_a?(String) } }
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:divide)
.and_expose(:division_completed, %i[final_number])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue(number1: arg1, number2: arg2)
end
def divide(number1:, number2:)
Continue(final_number: (number1 / number2).to_s)
end
end
class Divide2
include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: { division_completed: ->(value) { value[:final_number].is_a?(Numeric) } },
failure: { invalid_arg: ->(value) { value[:message].is_a?(String) } }
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:divide)
.and_expose(:ok, %i[final_number])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Continue(number1: arg1, number2: arg2)
end
def divide(number1:, number2:)
Continue(final_number: (number1 / number2))
end
end
test '#and_expose validates the exposed value' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide1.new.call(12, 2)
end
assert_equal('value {:final_number=>"6"} is not allowed for :division_completed type', err1.message)
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide2.new.call(12, 2)
end
assert_equal('type :ok is not allowed. Allowed types: :division_completed', err2.message)
end
end
end
solid-result-2.0.0/test/solid/output/and_expose/failure_test.rb 0000664 0000000 0000000 00000002241 14606620746 0024742 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndExposeFailureTest < Minitest::Test
class Divide
include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:divide)
.and_expose(:division_completed, %i[final_number])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def divide(number1:, number2:)
Success(:division_completed, final_number: (number1 / number2))
end
end
test '#and_expose returns the failure itself if the result is a failure' do
failure1 = Divide.new.call('12', 2)
failure2 = Divide.new.call(12, '2')
assert failure1.failure?(:invalid_arg)
assert failure2.failure?(:invalid_arg)
assert_equal({ message: 'arg1 must be numeric' }, failure1.value)
assert_equal({ message: 'arg2 must be numeric' }, failure2.value)
end
end
end
solid-result-2.0.0/test/solid/output/and_expose/intermediate_values_test.rb 0000664 0000000 0000000 00000002037 14606620746 0027347 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndExposeIntermediateValuesTest < Minitest::Test
class Divide
include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:divide, extra_division: 2)
.and_expose(:numbers, %i[number1 number2])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def divide(number1:, number2:, extra_division:)
Success(:division_completed, final_number: (number1 / number2) / extra_division)
end
end
test '#and_expose can expose all the values (accumulated or not)' do
result = Divide.new.call(12, 2)
assert result.success?(:numbers)
assert_equal({ number1: 12, number2: 2 }, result.value)
end
end
end
solid-result-2.0.0/test/solid/output/and_expose/invalid_keys_test.rb 0000664 0000000 0000000 00000002256 14606620746 0026002 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndExposeInvalidKeysTest < Minitest::Test
class Divide
include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:divide, extra_division: 2)
.and_expose(:division_completed, %i[final_numbers extra_division number1 number2])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def divide(number1:, number2:, extra_division:)
Success(:division_completed, final_number: (number1 / number2) / extra_division)
end
end
test '#and_expose receive an invalid key' do
err = assert_raises(Solid::Output::Error::InvalidExposure) { Divide.new.call(12, 2) }
assert err.message.start_with?('key not found: :final_numbers')
assert err.message.end_with?('. Available to expose: :number1, :number2, :extra_division, :final_number')
end
end
end
solid-result-2.0.0/test/solid/output/and_expose/one_value_test.rb 0000664 0000000 0000000 00000002040 14606620746 0025265 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndExposeOneValueTest < Minitest::Test
class Divide
include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:divide, extra_division: 2)
.and_expose(:division_completed, %i[final_number])
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def divide(number1:, number2:, extra_division:)
Success(:division_completed, final_number: (number1 / number2) / extra_division)
end
end
test '#and_expose can expose all the values (accumulated or not)' do
result = Divide.new.call(12, 2)
assert result.success?(:division_completed)
assert_equal({ final_number: 3 }, result.value)
end
end
end
solid-result-2.0.0/test/solid/output/and_expose/termination_test.rb 0000664 0000000 0000000 00000004200 14606620746 0025641 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputTerminationTest < Minitest::Test
module TerminationEnabledAndThenBlock
extend self, Output.mixin
def call
Success(:a, a: 1)
.and_then { Success(:b, b: 2) }
.and_expose(:a_and_b, %i[a b]) # the default is terminal
.and_then { Success(:c, c: 3) }
end
end
module TerminationEnabledAndThenMethod
extend self, Output.mixin
def call
call_a
.and_then(:call_b)
.and_expose(:a_and_b, %i[a b]) # the default is terminal
.and_then(:call_c)
end
private
def call_a; Success(:a, a: 1); end
def call_b; Success(:b, b: 2); end
def call_c; Success(:c, c: 3); end
end
module TerminationDisabledAndThenBlock
extend self, Output.mixin
def call
Success(:a, a: 1)
.and_then { Success(:b, b: 2) }
.and_expose(:a_and_b, %i[a b], terminal: false)
.and_then { Success(:c, c: 3) }
end
end
module TerminationDisabledAndThenMethod
extend self, Output.mixin
def call
call_a
.and_then(:call_b)
.and_expose(:a_and_b, %i[a b], terminal: false)
.and_then(:call_c)
end
private
def call_a; Success(:a, a: 1); end
def call_b; Success(:b, b: 2); end
def call_c; Success(:c, c: 3); end
end
test 'by default, #and_expose terminates the execution' do
result1 = TerminationEnabledAndThenBlock.call
result2 = TerminationEnabledAndThenMethod.call
assert result1.success?(:a_and_b)
assert_equal({ a: 1, b: 2 }, result1.value)
assert result2.success?(:a_and_b)
assert_equal({ a: 1, b: 2 }, result2.value)
end
test 'when terminal is false, #and_expose does not terminates the execution' do
result1 = TerminationDisabledAndThenBlock.call
result2 = TerminationDisabledAndThenMethod.call
assert result1.success?(:c)
assert_equal({ c: 3 }, result1.value)
assert result2.success?(:c)
assert_equal({ c: 3 }, result2.value)
end
end
end
solid-result-2.0.0/test/solid/output/and_then/ 0000775 0000000 0000000 00000000000 14606620746 0021363 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/and_then/argument_error_test.rb 0000664 0000000 0000000 00000001165 14606620746 0026005 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndThenArgumentErrorTest < Minitest::Test
module SomeModule
extend Solid::Output.mixin
def self.call(arg1, arg2)
Success(:ok, number: arg1 + arg2)
.and_then(:some_method_name) { :method_name_and_block_are_not_allowed }
end
end
test 'raises ArgumentError when the method name and block are both given' do
error = assert_raises(ArgumentError) { SomeModule.call(1, 2) }
assert_equal(
'method_name and block are mutually exclusive',
error.message
)
end
end
end
solid-result-2.0.0/test/solid/output/and_then/with_source_test.rb 0000664 0000000 0000000 00000014311 14606620746 0025302 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndThenWithSourceTest < Minitest::Test
class Base
include Solid::Output.mixin
attr_reader :arg1, :arg2
def initialize(arg1, arg2)
@arg1 = arg1
@arg2 = arg2
end
def call; end
private
def validate_numbers
return Success(:ok) if arg1.is_a?(::Numeric) && arg2.is_a?(::Numeric)
Failure(:invalid_arg, message: 'both arguments must be numeric')
end
end
class SourceMethodArityWithArityZero < Base
def call
validate_numbers.and_then(:add)
end
private
def add
Success(:ok, number: arg1 + arg2)
end
end
class SourceMethodArityWithArityOneKarg < Base
def call
validate_numbers
.and_then { Success(:ok, number1: arg1, number2: arg2) }
.and_then(:add)
end
def add(number1:, number2:)
Success(:ok, number: number1 + number2)
end
end
class SourceMethodArityWithArityOneArg < Base
def call
validate_numbers
.and_then { Success(:ok, number1: arg1, number2: arg2) }
.and_then(:add)
end
def add(args)
Success(:ok, number: args)
end
end
class SourceMethodArityWithOutputData < Base
def call
validate_numbers
.and_then { Success(:ok, number1: arg1, number2: arg2) }
.and_then(:add, number3: 3)
end
def add(number1:, number2:, number3:)
Success(:ok, number: number1 + number2 + number3)
end
end
class InvalidSourceMethodArity < Base
def call
validate_numbers.and_then(:add)
end
def add(number1, number2)
Success(:ok, number: number1 + number2)
end
end
class InvalidResultSourceFromBlock < Base
def add_instance
@add_instance ||= SourceMethodArityWithArityZero.new(arg1, arg2)
end
def call
validate_numbers.and_then { add_instance.call }
end
end
class InvalidResultSourceFromMethod < Base
def add_instance
@add_instance ||= SourceMethodArityWithArityZero.new(arg1, arg2)
end
def call
validate_numbers.and_then(:add)
end
def add
add_instance.call
end
end
class UnexpectedBlockOutcome < Base
def call
validate_numbers.and_then { arg1 + arg2 }
end
end
class UnexpectedMethodOutcome < Base
def call
validate_numbers.and_then(:add)
end
def add
arg1 + arg2
end
end
test '#and_then calling a source method (arity 0)' do
result = SourceMethodArityWithArityZero.new(1, 2).call
assert_predicate(result, :success?)
assert_equal(:ok, result.type)
assert_equal({ number: 3 }, result.value)
end
test '#and_then calling a source method (arity 1 - keyword args)' do
result = SourceMethodArityWithArityOneKarg.new(1, 2).call
assert_predicate(result, :success?)
assert_equal(:ok, result.type)
assert_equal({ number: 3 }, result.value)
end
test '#and_then calling a source method with context data' do
result = SourceMethodArityWithOutputData.new(1, 2).call
assert_predicate(result, :success?)
assert_equal(:ok, result.type)
assert_equal({ number: 6 }, result.value)
end
test '#and_then calling a source method (arity 1 - positional arg)' do
invalid_source_method = SourceMethodArityWithArityOneArg.new(1, 2)
error = assert_raises(Solid::Result::Error::InvalidSourceMethodArity) { invalid_source_method.call }
assert_match(/#add has unsupported arity \(1\). Expected 0..1\z/, error.message)
end
test '#and_then calling a source method with wrong arity (> 1)' do
wrong_source_method_arity = InvalidSourceMethodArity.new(1, 2)
error = assert_raises(Solid::Result::Error::InvalidSourceMethodArity) { wrong_source_method_arity.call }
assert_match(/#add has unsupported arity \(2\). Expected 0..1\z/, error.message)
end
test '#and_then raises an error when the block returns a result that does not belongs to the source' do
wrong_result_source = InvalidResultSourceFromBlock.new(1, 2)
error = assert_raises(Solid::Result::Error::InvalidResultSource) { wrong_result_source.call }
expected_message =
"You cannot call #and_then and return a result that does not belong to the same source!\n" \
"Expected source: #{wrong_result_source.inspect}\n" \
"Given source: #{wrong_result_source.add_instance.inspect}\n" \
'Given result: #3}>'
assert_equal(expected_message, error.message)
end
test '#and_then raises an error when the called method returns a result that does not belongs to the source' do
wrong_result_source = InvalidResultSourceFromMethod.new(1, 2)
error = assert_raises(Solid::Result::Error::InvalidResultSource) { wrong_result_source.call }
expected_message =
"You cannot call #and_then and return a result that does not belong to the same source!\n" \
"Expected source: #{wrong_result_source.inspect}\n" \
"Given source: #{wrong_result_source.add_instance.inspect}\n" \
'Given result: #3}>'
assert_equal(expected_message, error.message)
end
test '#and_then raises an error when the block returns a non-result object' do
error = assert_raises(Solid::Result::Error::UnexpectedOutcome) { UnexpectedBlockOutcome.new(1, 2).call }
expected_message =
'Unexpected outcome: 3. The block must return this object wrapped by ' \
'Solid::Output::Success or Solid::Output::Failure'
assert_equal(expected_message, error.message)
end
test '#and_then raises an error when the method returns a non-result object' do
error = assert_raises(Solid::Result::Error::UnexpectedOutcome) { UnexpectedMethodOutcome.new(1, 2).call }
expected_message =
'Unexpected outcome: 3. The method must return this object wrapped by ' \
'Solid::Output::Success or Solid::Output::Failure'
assert_equal(expected_message, error.message)
end
end
end
solid-result-2.0.0/test/solid/output/and_then/without_source_test.rb 0000664 0000000 0000000 00000004447 14606620746 0026043 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputAndThenWithoutSourceTest < Minitest::Test
test '#and_then does not execute the block if the result is a failure' do
result =
Output::Success
.new(type: :one, value: { number: 1 })
.and_then { Output::Failure(:two, number: 2) }
.and_then { Output::Success(:three, number: 3) }
.and_then { Output::Success(:four, number: 4) }
assert result.failure?(:two)
assert_equal({ number: 2 }, result.value)
end
test '#and_then executes the block if the result is a success' do
result =
Output::Success(:one, number: 1)
.and_then { Output::Success(:two, number: 2) }
.and_then { Output::Success(:three, number: 3) }
.and_then { Output::Success(:four, number: 4) }
assert result.success?(:four)
assert_equal({ number: 4 }, result.value)
end
test '#and_then does not handle an exception raised in the block' do
assert_raises(RuntimeError) do
Output::Success(:one, number: 1)
.and_then { Output::Success(:two, number: 2) }
.and_then { raise 'boom' }
end
end
test '#and_then raises an exception if the block does not return a solid output (regular object)' do
error = assert_raises(Solid::Output::Error::UnexpectedOutcome) do
Output::Success(:one, number: 1)
.and_then { Output::Success(:two, number: 2) }
.and_then { 3 }
end
assert_equal(
'Unexpected outcome: 3. The block must return this object wrapped by ' \
'Solid::Output::Success or Solid::Output::Failure',
error.message
)
end
test '#and_then raises an exception if the block does not return a solid output (Solid::Result)' do
error = assert_raises(Solid::Output::Error::UnexpectedOutcome) do
Output::Success(:one, number: 1)
.and_then { Output::Success(:two, number: 2) }
.and_then { Solid::Result::Success(:three, number: 3) }
end
assert_equal(
'Unexpected outcome: #3}>. ' \
'The block must return this object wrapped by Solid::Output::Success or Solid::Output::Failure',
error.message
)
end
end
end
solid-result-2.0.0/test/solid/output/callable_and_then/ 0000775 0000000 0000000 00000000000 14606620746 0023202 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/callable_and_then/accumulation_test.rb 0000664 0000000 0000000 00000006464 14606620746 0027264 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::CallableAndThenResultFromDifferentSourcesTest < Minitest::Test
include SolidResultEventLogAssertions
# rubocop:disable Naming/MethodParameterName
class Root
include Output.mixin
CallC = ->(b:, **) do
Solid::Result.event_logs(name: 'CallC') do
Output::Success(:c, c: b + 1)
end
end
CallE = ->(d:, **) do
Solid::Result.event_logs(name: 'CallE') do
Output::Success(:e, e: d + 1)
end
end
def call(a:)
Solid::Result.event_logs(name: 'Root') do
Given(a: a)
.and_then(:call_b, b: 2)
.and_then!(CallC)
.and_then!(self, _call: :call_d)
.and_then!(CallE, f: 5)
.and_then!(self, _call: :call_g, h: 7)
.and_expose(:everything, %i[a b c d e f g h])
end
end
def call_b(b:, **)
Success(:b, b: b)
end
def call_d(c:, **)
Success(:d, d: c + 1)
end
def call_g(f:, **)
Success(:g, g: f + 1)
end
end
# rubocop:enable Naming/MethodParameterName
test 'the data accumulation' do
root_process = Root.new
result = root_process.call(a: 1)
assert(result.success?(:everything))
assert_equal(
{ a: 1, b: 2, c: 3, d: 4, e: 5, f: 5, g: 6, h: 7 },
result.value
)
assert_event_logs(result, size: 7)
root = { id: 0, name: 'Root', desc: nil }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :_given_, value: { a: 1 }, source: root_process }
}.then { assert_event_log_record(result, 0, _1) }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :b, value: { b: 2 }, source: root_process },
and_then: { type: :method, arg: { b: 2 }, method_name: :call_b }
}.then { assert_event_log_record(result, 1, _1) }
{
root: root,
parent: root,
current: { id: 1, name: 'CallC', desc: nil },
result: { kind: :success, type: :c, value: { c: 3 }, source: nil }
}.then { assert_event_log_record(result, 2, _1) }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :d, value: { d: 4 }, source: root_process },
and_then: { type: :method, arg: -> { _1.is_a?(Hash) && _1.empty? }, method_name: :call_d }
}.then { assert_event_log_record(result, 3, _1) }
{
root: root,
parent: root,
current: { id: 2, name: 'CallE', desc: nil },
result: { kind: :success, type: :e, value: { e: 5 }, source: nil }
}.then { assert_event_log_record(result, 4, _1) }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :g, value: { g: 6 }, source: root_process },
and_then: { type: :method, arg: { h: 7 }, method_name: :call_g }
}.then { assert_event_log_record(result, 5, _1) }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :everything, value: { a: 1, b: 2, c: 3, d: 4, e: 5, f: 5, g: 6, h: 7 } }
}.then { assert_event_log_record(result, 6, _1) }
end
end
end
solid-result-2.0.0/test/solid/output/callable_and_then/arity_test.rb 0000664 0000000 0000000 00000007315 14606620746 0025724 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::CallableAndThenArityTest < Minitest::Test
# rubocop:disable Naming/MethodParameterName
ProcWithoutKarg = proc { Output::Success(:ok, o: -1) }
ProcWithOneKarg = proc { |n:| Output::Success(:ok, o: n) }
ProcWithTwoKargs = proc { |n:, m:| Output::Success(:ok, o: [n, m]) }
ProcWithArgAndKarg = proc { |foo, bar:| Output::Success(:ok, o: [foo, bar]) }
LambdaWithoutKarg = -> { Output::Success(:ok, o: -1) }
LambdaWithOneKarg = ->(n:) { Output::Success(:ok, o: n) }
LambdaWithTwoKargs = ->(n:, m:) { Output::Success(:ok, o: [n, m]) }
LambdaWithArgAndKarg = ->(foo, bar:) { Output::Success(:ok, o: [foo, bar]) }
module ModWithoutKarg
def self.call; Output::Success(:ok, o: -1); end
end
module ModWithOneKarg
def self.call(n:); Output::Success(:ok, o: n); end
end
module ModWithTwoKargs
def self.call(n:, m:); Output::Success(:ok, o: [n, m]); end
end
module ModWithArgAndKarg
def self.call(foo, bar:); Output::Success(:ok, o: [foo, bar]); end
end
# rubocop:enable Naming/MethodParameterName
def setup
Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
Solid::Result.config.feature.disable!(:and_then!)
end
test 'zero kargs' do
err1 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Output::Success(:ok, o: 0).and_then!(ProcWithoutKarg)
end
err2 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Output::Success(:ok, o: 0).and_then!(LambdaWithoutKarg)
end
err3 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Output::Success(:ok, o: 0).and_then!(ModWithoutKarg)
end
assert_equal 'Invalid arity for Proc#call method. Expected arity: only keyword args', err1.message
assert_equal 'Invalid arity for Proc#call method. Expected arity: only keyword args', err2.message
assert_equal 'Invalid arity for Module#call method. Expected arity: only keyword args', err3.message
end
test 'one karg' do
result1 = Output::Success(:ok, n: 1).and_then!(ProcWithOneKarg)
result2 = Output::Success(:ok, n: 2).and_then!(LambdaWithOneKarg)
result3 = Output::Success(:ok, n: 3).and_then!(ModWithOneKarg)
assert_equal 1, result1.value[:o]
assert_equal 2, result2.value[:o]
assert_equal 3, result3.value[:o]
end
test 'two kargs' do
result1 = Output::Success(:ok, n: 1).and_then!(ProcWithTwoKargs, m: 2)
result2 = Output::Success(:ok, n: 2).and_then!(LambdaWithTwoKargs, m: 3)
result3 = Output::Success(:ok, n: 3).and_then!(ModWithTwoKargs, m: 4)
assert_equal([1, 2], result1.value[:o])
assert_equal([2, 3], result2.value[:o])
assert_equal([3, 4], result3.value[:o])
end
test 'one arg and one karg' do
err1 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Output::Success(:ok, o: 0).and_then!(ProcWithArgAndKarg, bar: 1)
end
err2 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Output::Success(:ok, o: 0).and_then!(LambdaWithArgAndKarg, bar: 2)
end
err3 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Output::Success(:ok, o: 0).and_then!(ModWithArgAndKarg, bar: 3)
end
assert_equal 'Invalid arity for Proc#call method. Expected arity: only keyword args', err1.message
assert_equal 'Invalid arity for Proc#call method. Expected arity: only keyword args', err2.message
assert_equal 'Invalid arity for Module#call method. Expected arity: only keyword args', err3.message
end
end
end
solid-result-2.0.0/test/solid/output/callable_and_then/result_kind_error_test.rb 0000664 0000000 0000000 00000002665 14606620746 0030333 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::CallableAndThenResultKindErrorTest < Minitest::Test
module NormalizeEmail
extend Output.mixin
def self.call(input:)
Solid::Result.event_logs(name: 'NormalizeEmail') do
Given(input: input).and_then(:normalize)
end
end
def self.normalize(input:)
input.is_a?(::String) or return ::Solid::Result::Failure(:invalid_input, message: 'input must be a String')
::Solid::Result::Success(:normalized_input, input: input.downcase.strip)
end
end
module EmailNormalization
extend Output.mixin
def self.call(input)
Solid::Result.event_logs(name: 'EmailNormalization') do
Given(input: input)
.and_then!(NormalizeEmail)
end
end
end
test 'results from different sources' do
Solid::Result.config.feature.enable!(:and_then!)
error = assert_raises(Solid::Result::Error::UnexpectedOutcome) { EmailNormalization.call(nil) }
expected_message = [
'Unexpected outcome: #"input must be a String"}>.',
'The method must return this object wrapped by Solid::Output::Success or Solid::Output::Failure'
].join(' ')
assert_equal(expected_message, error.message)
ensure
Solid::Result.config.feature.disable!(:and_then!)
end
end
end
solid-result-2.0.0/test/solid/output/callable_and_then/results_from_different_sources_test.rb 0000664 0000000 0000000 00000012166 14606620746 0033111 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::CallableAndThenResultFromDifferentSourcesTest < Minitest::Test
include SolidResultEventLogAssertions
module NormalizeEmail
extend Output.mixin
def self.call(input:)
Solid::Result.event_logs(name: 'NormalizeEmail') do
Given(input: input).and_then(:normalize)
end
end
def self.normalize(input:)
input.is_a?(::String) or return Failure(:invalid_input, message: 'input must be a String')
Success(:normalized_input, input: input.downcase.strip)
end
end
class EmailValidation
include Output.mixin
def initialize(expected_pattern: /\A[^@\s]+@[^@\s]+\z/)
@expected_pattern = expected_pattern
end
def call(input:)
Solid::Result.event_logs(name: 'EmailValidation') do
Given(input: input).and_then(:validate)
end
end
def validate(input:)
input.match?(@expected_pattern) ? Success(:valid_email, email: input) : Failure(:invalid_email, email: input)
end
end
module NormalizeAndValidateEmail
extend Output.mixin
def self.call(input)
Solid::Result.event_logs(name: 'NormalizeAndValidateEmail') do
Given(input: input)
.and_then!(NormalizeEmail)
.and_then!(EmailValidation.new)
end
end
end
def setup
Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
Solid::Result.config.feature.disable!(:and_then!)
end
test 'results from different sources' do
result1 = NormalizeAndValidateEmail.call(nil)
result2 = NormalizeAndValidateEmail.call(' ')
result3 = NormalizeAndValidateEmail.call(" FOO@bAr.com \n")
assert(result1.failure?(:invalid_input))
assert_equal('input must be a String', result1.value[:message])
assert(result2.failure?(:invalid_email))
assert_equal('', result2.value[:email])
assert(result3.success?(:valid_email))
assert_equal('foo@bar.com', result3.value[:email])
end
test 'the event_logs tracking' do
result1 = NormalizeAndValidateEmail.call(1)
assert_event_logs(result1, size: 3)
assert_equal([0, [[1, []]]], result1.event_logs[:metadata][:ids][:tree])
root = { id: 0, name: 'NormalizeAndValidateEmail', desc: nil }
source = -> { _1 == NormalizeAndValidateEmail }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :_given_, value: { input: 1 }, source: source }
}.then { assert_event_log_record(result1, 0, _1) }
source = -> { _1 == NormalizeEmail }
{
root: root,
parent: root,
current: { id: 1, name: 'NormalizeEmail', desc: nil },
result: { kind: :success, type: :_given_, value: { input: 1 }, source: source }
}.then { assert_event_log_record(result1, 1, _1) }
{
root: root,
parent: root,
current: { id: 1, name: 'NormalizeEmail', desc: nil },
result: { kind: :failure, type: :invalid_input, value: { message: 'input must be a String' }, source: source },
and_then: { type: :method, arg: {}, method_name: :normalize }
}.then { assert_event_log_record(result1, 2, _1) }
# ---
result2 = NormalizeAndValidateEmail.call(" FOO@bAr.com \n")
assert_event_logs(result2, size: 5)
assert_equal([0, [[1, []], [2, []]]], result2.event_logs[:metadata][:ids][:tree])
root = { id: 0, name: 'NormalizeAndValidateEmail', desc: nil }
source = -> { _1 == NormalizeAndValidateEmail }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :_given_, value: { input: " FOO@bAr.com \n" }, source: source }
}.then { assert_event_log_record(result2, 0, _1) }
source = -> { _1 == NormalizeEmail }
{
root: root,
parent: root,
current: { id: 1, name: 'NormalizeEmail', desc: nil },
result: { kind: :success, type: :_given_, value: { input: " FOO@bAr.com \n" }, source: source }
}.then { assert_event_log_record(result2, 1, _1) }
{
root: root,
parent: root,
current: { id: 1, name: 'NormalizeEmail', desc: nil },
result: { kind: :success, type: :normalized_input, value: { input: 'foo@bar.com' }, source: source },
and_then: { type: :method, arg: {}, method_name: :normalize }
}.then { assert_event_log_record(result2, 2, _1) }
{
root: root,
parent: root,
current: { id: 2, name: 'EmailValidation', desc: nil },
result: { kind: :success, type: :_given_, value: { input: 'foo@bar.com' }, source: EmailValidation }
}.then { assert_event_log_record(result2, 3, _1) }
{
root: root,
parent: root,
current: { id: 2, name: 'EmailValidation', desc: nil },
result: { kind: :success, type: :valid_email, value: { email: 'foo@bar.com' }, source: EmailValidation },
and_then: { type: :method, arg: {}, method_name: :validate }
}.then { assert_event_log_record(result2, 4, _1) }
end
end
end
solid-result-2.0.0/test/solid/output/callable_and_then/unexpected_outcome_test.rb 0000664 0000000 0000000 00000002201 14606620746 0030460 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::CallableAndThenUnexpectedOutcomeTest < Minitest::Test
ProcWithArg = proc { |arg:| arg }
module ModWithArg
def self.call(arg:); arg; end
end
def setup
Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
Solid::Result.config.feature.disable!(:and_then!)
end
test 'unexpected outcome' do
err1 = assert_raises(Solid::Result::CallableAndThen::Error::UnexpectedOutcome) do
Output::Success(:ok, arg: 0).and_then!(ProcWithArg)
end
err2 = assert_raises(Solid::Result::CallableAndThen::Error::UnexpectedOutcome) do
Output::Success(:ok, arg: 0).and_then!(ModWithArg)
end
expected_kinds = 'Solid::Output::Success or Solid::Output::Failure'
assert_match(
/Unexpected outcome: 0. The # must return this object wrapped by #{expected_kinds}/,
err1.message
)
assert_match(
/Unexpected outcome: 0. The .+::ModWithArg must return this object wrapped by #{expected_kinds}/,
err2.message
)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/ 0000775 0000000 0000000 00000000000 14606620746 0021750 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/disabled/ 0000775 0000000 0000000 00000000000 14606620746 0023517 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/disabled/with_source/ 0000775 0000000 0000000 00000000000 14606620746 0026052 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/disabled/with_source/flat_test.rb 0000664 0000000 0000000 00000005176 14606620746 0030375 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsDisabledWithSourceInstanceFlatTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
class Division
include Output.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num2 must be numeric')
Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Success(:ok)
end
def divide(num1:, num2:)
Success(:ok, number: num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.new.call('4', 2)
result2 = Division.new.call(4, '2')
result3 = Division.new.call(4, 0)
result4 = Division.new.call(4, 2)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.new.call('4', 2) }
t2 = Thread.new { Division.new.call(4, '2') }
t3 = Thread.new { Division.new.call(4, 0) }
t4 = Thread.new { Division.new.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
result2 = Division.new.call(4, 2)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.new.call(4, 2)
result2 = Division.new.call(4, 0)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/disabled/with_source/nested_test.rb 0000664 0000000 0000000 00000006516 14606620746 0030730 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsDisabledWithSourceInstanceNestedTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
module Division
extend self, Output.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num2 must be numeric')
Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Success(:ok)
end
def divide(num1:, num2:)
Success(:ok, number: num1 / num2)
end
end
class SumDivisionsByTwo
include Output.mixin
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
else
Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
private
def divide_by_two(num)
Division.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.new.call('30', '20', '10')
result2 = SumDivisionsByTwo.new.call(30, '20', '10')
result3 = SumDivisionsByTwo.new.call(30, 20, '10')
result4 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.new.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.new.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.new.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.new.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
result2 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
result2 = SumDivisionsByTwo.new.call(30, 20, '10')
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/disabled/with_source/recursion_test.rb 0000664 0000000 0000000 00000003036 14606620746 0031451 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsDisabledWithSourceInstanceRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
class Fibonacci
include Solid::Output.mixin
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
fibonacci = number <= 1 ? number : call(number - 1).value[:number] + call(number - 2).value[:number]
Success(:fibonacci, number: fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Failure(:invalid_input, message: 'input must be numeric')
input.negative? and return Failure(:negative_number, message: 'number cannot be negative')
Success(:positive_number, number: input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.new.call('1')
failure2 = Fibonacci.new.call(-1)
fibonacci0 = Fibonacci.new.call(0)
fibonacci1 = Fibonacci.new.call(1)
fibonacci2 = Fibonacci.new.call(2)
assert_empty_event_logs(failure1)
assert_empty_event_logs(failure2)
assert_empty_event_logs(fibonacci0)
assert_empty_event_logs(fibonacci1)
assert_empty_event_logs(fibonacci2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/disabled/without_source/ 0000775 0000000 0000000 00000000000 14606620746 0026602 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/disabled/without_source/flat_test.rb 0000664 0000000 0000000 00000005243 14606620746 0031120 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsDisabledWithoutSourceInstanceFlatTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
module Division
extend self
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num2 must be numeric')
Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Output::Success(:ok)
end
def divide(num1:, num2:)
Output::Success(:ok, number: num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.call('4', 2)
result2 = Division.call(4, '2')
result3 = Division.call(4, 0)
result4 = Division.call(4, 2)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.call('4', 2) }
t2 = Thread.new { Division.call(4, '2') }
t3 = Thread.new { Division.call(4, 0) }
t4 = Thread.new { Division.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
result2 = Division.call(4, 2)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.call(4, 2)
result2 = Division.call(4, 0)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/disabled/without_source/nested_test.rb 0000664 0000000 0000000 00000006545 14606620746 0031462 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsDisabledWithoutSourceInstanceNestedTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
class Division
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num2 must be numeric')
Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Output::Success(:ok)
end
def divide(num1:, num2:)
Output::Success(:ok, number: num1 / num2)
end
end
module SumDivisionsByTwo
extend self
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Output::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
else
Output::Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
private
def divide_by_two(num)
Division.new.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.call('30', '20', '10')
result2 = SumDivisionsByTwo.call(30, '20', '10')
result3 = SumDivisionsByTwo.call(30, 20, '10')
result4 = SumDivisionsByTwo.call(30, 20, 10)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
result2 = SumDivisionsByTwo.call(30, 20, 10)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
result2 = SumDivisionsByTwo.call(30, 20, '10')
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/disabled/without_source/recursion_test.rb 0000664 0000000 0000000 00000003036 14606620746 0032201 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsDisabledWithoutSourceInstanceRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
module Fibonacci
extend self
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
fibonacci = number <= 1 ? number : call(number - 1).value[:number] + call(number - 2).value[:number]
Output::Success(:fibonacci, number: fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Output::Failure(:invalid_input, message: 'input must be numeric')
input.negative? and return Output::Failure(:negative_number, message: 'number cannot be negative')
Output::Success(:positive_number, number: input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.call('1')
failure2 = Fibonacci.call(-1)
fibonacci0 = Fibonacci.call(0)
fibonacci1 = Fibonacci.call(1)
fibonacci2 = Fibonacci.call(2)
assert_empty_event_logs(failure1)
assert_empty_event_logs(failure2)
assert_empty_event_logs(fibonacci0)
assert_empty_event_logs(fibonacci1)
assert_empty_event_logs(fibonacci2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/ 0000775 0000000 0000000 00000000000 14606620746 0023342 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/enabled/not_been_started_test.rb 0000664 0000000 0000000 00000000633 14606620746 0030247 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsNotBeenStartedTest < Minitest::Test
include SolidResultEventLogAssertions
test 'event_logs is empty by default' do
success = Output::Success(:ok, one: 1)
failure = Output::Failure(:err, zero: 0)
assert_event_logs(success, size: 0)
assert_event_logs(failure, size: 0)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/ 0000775 0000000 0000000 00000000000 14606620746 0025675 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/instance/ 0000775 0000000 0000000 00000000000 14606620746 0027501 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/instance/flat_test.rb 0000664 0000000 0000000 00000004777 14606620746 0032032 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithSourceInstanceFlatTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
include Output.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num2 must be numeric')
Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Success(:ok)
end
def divide(num1:, num2:)
Success(:ok, number: num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.new.call('4', 2)
result2 = Division.new.call(4, '2')
result3 = Division.new.call(4, 0)
result4 = Division.new.call(4, 2)
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.new.call('4', 2) }
t2 = Thread.new { Division.new.call(4, '2') }
t3 = Thread.new { Division.new.call(4, 0) }
t4 = Thread.new { Division.new.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
result2 = Division.new.call(4, 2)
assert_event_logs(result1, size: 2)
assert_event_logs(result2, size: 3)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.new.call(4, 2)
result2 = Division.new.call(4, 0)
assert_event_logs(result1, size: 3)
assert_event_logs(result2, size: 2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/instance/nested_test.rb 0000664 0000000 0000000 00000006321 14606620746 0032351 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithSourceInstanceNestedTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
include Output.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num2 must be numeric')
Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Success(:ok)
end
def divide(num1:, num2:)
Success(:ok, number: num1 / num2)
end
end
class SumDivisionsByTwo
include Output.mixin
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
else
Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
private
def divide_by_two(num)
Division.new.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.new.call('30', '20', '10')
result2 = SumDivisionsByTwo.new.call(30, '20', '10')
result3 = SumDivisionsByTwo.new.call(30, 20, '10')
result4 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.new.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.new.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.new.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.new.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
result2 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_event_logs(result1, size: 8)
assert_event_logs(result2, size: 10)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
result2 = SumDivisionsByTwo.new.call(30, 20, '10')
assert_event_logs(result1, size: 10)
assert_event_logs(result2, size: 8)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/instance/recursion_test.rb 0000664 0000000 0000000 00000002612 14606620746 0033077 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithSourceInstanceRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
class Fibonacci
include Solid::Output.mixin
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
fibonacci = number <= 1 ? number : call(number - 1).value[:number] + call(number - 2).value[:number]
Success(:fibonacci, number: fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Failure(:invalid_input, message: 'input must be numeric')
input.negative? and return Failure(:negative_number, message: 'number cannot be negative')
Success(:positive_number, number: input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.new.call('1')
failure2 = Fibonacci.new.call(-1)
fibonacci0 = Fibonacci.new.call(0)
fibonacci1 = Fibonacci.new.call(1)
fibonacci2 = Fibonacci.new.call(2)
assert_event_logs(failure1, size: 1)
assert_event_logs(failure2, size: 1)
assert_event_logs(fibonacci0, size: 2)
assert_event_logs(fibonacci1, size: 2)
assert_event_logs(fibonacci2, size: 6)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/singleton/ 0000775 0000000 0000000 00000000000 14606620746 0027677 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/singleton/flat_test.rb 0000664 0000000 0000000 00000004726 14606620746 0032222 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithSourceSingletonFlatTest < Minitest::Test
include SolidResultEventLogAssertions
module Division
extend self, Output.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num2 must be numeric')
Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Success(:ok)
end
def divide(num1:, num2:)
Success(:ok, number: num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.call('4', 2)
result2 = Division.call(4, '2')
result3 = Division.call(4, 0)
result4 = Division.call(4, 2)
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.call('4', 2) }
t2 = Thread.new { Division.call(4, '2') }
t3 = Thread.new { Division.call(4, 0) }
t4 = Thread.new { Division.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
result2 = Division.call(4, 2)
assert_event_logs(result1, size: 2)
assert_event_logs(result2, size: 3)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.call(4, 2)
result2 = Division.call(4, 0)
assert_event_logs(result1, size: 3)
assert_event_logs(result2, size: 2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/singleton/nested_test.rb 0000664 0000000 0000000 00000020664 14606620746 0032555 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithSourceSingletonNestedTest < Minitest::Test
include SolidResultEventLogAssertions
module Division
extend self, Output.mixin(config: { addon: { continue: true } })
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero, useless_arg: true)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, message: 'num2 must be numeric')
Continue(num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
num2.zero? ? Failure(:division_by_zero, message: 'num2 cannot be zero') : Continue()
end
def divide(num1:, num2:, **)
Success(:division_completed, number: num1 / num2)
end
end
module SumDivisionsByTwo
extend self, Output.mixin
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Failure(:errors, messages: divisions.select(&:failure?).map { _1.value[:message] })
else
Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
private
def divide_by_two(num)
Division.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.call('30', '20', '10')
result2 = SumDivisionsByTwo.call(30, '20', '10')
result3 = SumDivisionsByTwo.call(30, 20, '10')
result4 = SumDivisionsByTwo.call(30, 20, 10)
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
result2 = SumDivisionsByTwo.call(30, 20, 10)
assert_event_logs(result1, size: 8)
assert_event_logs(result2, size: 10)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
result2 = SumDivisionsByTwo.call(30, 20, '10')
assert_event_logs(result1, size: 10)
assert_event_logs(result2, size: 8)
end
test 'the tracking records (one level of nesting)' do
result = SumDivisionsByTwo.call('30', '20', '10')
last_event_log = result.event_logs[:records].last
assert_equal(last_event_log.dig(:current, :id), last_event_log.dig(:root, :id))
root = last_event_log.fetch(:current)
assert_hash_schema!({ id: Integer, name: nil, desc: nil }, root)
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :failure, type: :invalid_arg, value: { message: 'num1 must be numeric' }, source: Division }
}.then { |spec| assert_event_log_record(result, 0, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :failure, type: :invalid_arg, value: { message: 'num1 must be numeric' }, source: Division }
}.then { |spec| assert_event_log_record(result, 1, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :failure, type: :invalid_arg, value: { message: 'num1 must be numeric' }, source: Division }
}.then { |spec| assert_event_log_record(result, 2, spec) }
{
root: root,
parent: root,
current: root,
result: { kind: :failure, type: :errors, value: { messages: ['num1 must be numeric'] * 3 },
source: SumDivisionsByTwo }
}.then { |spec| assert_event_log_record(result, 3, spec) }
# ---
assert_equal(4, result.event_logs[:records].map { _1.dig(:current, :id) }.uniq.size)
assert_equal(4, result.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
end
test 'the tracking records (multiple level of nesting)' do
result = SumDivisionsByTwo.call('30', 20, 0)
last_event_log = result.event_logs[:records].last
assert_equal(last_event_log.dig(:current, :id), last_event_log.dig(:root, :id))
root = last_event_log.fetch(:current)
assert_hash_schema!({ id: Integer, name: nil, desc: nil }, root)
# 1st division event_log
#
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :failure, type: :invalid_arg, value: { message: 'num1 must be numeric' }, source: Division }
}.then { |spec| assert_event_log_record(result, 0, spec) }
# 2nd division event_logs
#
refute_equal(
result.event_logs[:records][0].dig(:current, :id),
result.event_logs[:records][1].dig(:current, :id)
)
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :success, type: :_continue_, value: { num1: 20, num2: 2 }, source: Division }
}.then { |spec| assert_event_log_record(result, 1, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :success, type: :_continue_, value: {}, source: Division },
and_then: { type: :method, arg: { useless_arg: true }, method_name: :validate_nonzero }
}.then { |spec| assert_event_log_record(result, 2, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :success, type: :division_completed, value: { number: 10 }, source: Division },
and_then: { type: :method, arg: {}, method_name: :divide }
}.then { |spec| assert_event_log_record(result, 3, spec) }
# 3rd division event_logs
#
refute_equal(
result.event_logs[:records][3].dig(:current, :id),
result.event_logs[:records][4].dig(:current, :id)
)
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :success, type: :_continue_, value: { num1: 0, num2: 2 }, source: Division }
}.then { |spec| assert_event_log_record(result, 4, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :success, type: :_continue_, value: {}, source: Division },
and_then: { type: :method, arg: { useless_arg: true }, method_name: :validate_nonzero }
}.then { |spec| assert_event_log_record(result, 5, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: nil, desc: nil },
result: { kind: :success, type: :division_completed, value: { number: 0 }, source: Division },
and_then: { type: :method, arg: {}, method_name: :divide }
}.then { |spec| assert_event_log_record(result, 6, spec) }
# Final result event_log
#
{
root: root,
parent: root,
current: root,
result: { kind: :failure, type: :errors, value: { messages: ['num1 must be numeric'] } }
}.then { |spec| assert_event_log_record(result, 7, spec) }
assert_equal(8, result.event_logs[:records].size)
assert_equal(4, result.event_logs[:records].map { _1.dig(:current, :id) }.uniq.size)
assert_equal(8, result.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/with_source/singleton/recursion_test.rb 0000664 0000000 0000000 00000002575 14606620746 0033305 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithSourceSingletonRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
module Fibonacci
extend self, Solid::Output.mixin
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
fibonacci = number <= 1 ? number : call(number - 1).value[:number] + call(number - 2).value[:number]
Success(:fibonacci, number: fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Failure(:invalid_input, message: 'input must be numeric')
input.negative? and return Failure(:negative_number, message: 'number cannot be negative')
Success(:positive_number, number: input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.call('1')
failure2 = Fibonacci.call(-1)
fibonacci0 = Fibonacci.call(0)
fibonacci1 = Fibonacci.call(1)
fibonacci2 = Fibonacci.call(2)
assert_event_logs(failure1, size: 1)
assert_event_logs(failure2, size: 1)
assert_event_logs(fibonacci0, size: 2)
assert_event_logs(fibonacci1, size: 2)
assert_event_logs(fibonacci2, size: 6)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/ 0000775 0000000 0000000 00000000000 14606620746 0026425 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/instance/ 0000775 0000000 0000000 00000000000 14606620746 0030231 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/instance/flat_test.rb 0000664 0000000 0000000 00000005100 14606620746 0032537 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithoutSourceInstanceFlatTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num2 must be numeric')
Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Output::Success(:ok)
end
def divide(num1:, num2:)
Output::Success(:ok, number: num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.new.call('4', 2)
result2 = Division.new.call(4, '2')
result3 = Division.new.call(4, 0)
result4 = Division.new.call(4, 2)
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.new.call('4', 2) }
t2 = Thread.new { Division.new.call(4, '2') }
t3 = Thread.new { Division.new.call(4, 0) }
t4 = Thread.new { Division.new.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
result2 = Division.new.call(4, 2)
assert_event_logs(result1, size: 2)
assert_event_logs(result2, size: 3)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.new.call(4, 2)
result2 = Division.new.call(4, 0)
assert_event_logs(result1, size: 3)
assert_event_logs(result2, size: 2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/instance/nested_test.rb 0000664 0000000 0000000 00000006406 14606620746 0033105 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithoutSourceInstanceNestedTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num2 must be numeric')
Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Output::Success(:ok)
end
def divide(num1:, num2:)
Output::Success(:ok, number: num1 / num2)
end
end
class SumDivisionsByTwo
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Output::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
else
Output::Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
private
def divide_by_two(num)
Division.new.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.new.call('30', '20', '10')
result2 = SumDivisionsByTwo.new.call(30, '20', '10')
result3 = SumDivisionsByTwo.new.call(30, 20, '10')
result4 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.new.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.new.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.new.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.new.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
result2 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_event_logs(result1, size: 8)
assert_event_logs(result2, size: 10)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
result2 = SumDivisionsByTwo.new.call(30, 20, '10')
assert_event_logs(result1, size: 10)
assert_event_logs(result2, size: 8)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/instance/recursion_test.rb 0000664 0000000 0000000 00000002612 14606620746 0033627 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithoutSourceInstanceRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
class Fibonacci
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
fibonacci = number <= 1 ? number : call(number - 1).value[:number] + call(number - 2).value[:number]
Output::Success(:fibonacci, number: fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Output::Failure(:invalid_input, message: 'input must be numeric')
input.negative? and return Output::Failure(:negative_number, message: 'number cannot be negative')
Output::Success(:positive_number, number: input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.new.call('1')
failure2 = Fibonacci.new.call(-1)
fibonacci0 = Fibonacci.new.call(0)
fibonacci1 = Fibonacci.new.call(1)
fibonacci2 = Fibonacci.new.call(2)
assert_event_logs(failure1, size: 1)
assert_event_logs(failure2, size: 1)
assert_event_logs(fibonacci0, size: 2)
assert_event_logs(fibonacci1, size: 2)
assert_event_logs(fibonacci2, size: 6)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/singleton/ 0000775 0000000 0000000 00000000000 14606620746 0030427 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/singleton/flat_test.rb 0000664 0000000 0000000 00000005045 14606620746 0032745 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithoutSourceSingletonFlatTest < Minitest::Test
include SolidResultEventLogAssertions
module Division
extend self
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num2 must be numeric')
Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Output::Success(:ok)
end
def divide(num1:, num2:)
Output::Success(:ok, number: num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.call('4', 2)
result2 = Division.call(4, '2')
result3 = Division.call(4, 0)
result4 = Division.call(4, 2)
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.call('4', 2) }
t2 = Thread.new { Division.call(4, '2') }
t3 = Thread.new { Division.call(4, 0) }
t4 = Thread.new { Division.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
result2 = Division.call(4, 2)
assert_event_logs(result1, size: 2)
assert_event_logs(result2, size: 3)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.call(4, 2)
result2 = Division.call(4, 0)
assert_event_logs(result1, size: 3)
assert_event_logs(result2, size: 2)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/singleton/nested_test.rb 0000664 0000000 0000000 00000006373 14606620746 0033306 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithoutSourceSingletonNestedTest < Minitest::Test
include SolidResultEventLogAssertions
module Division
extend self
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num1 must be numeric')
num2.is_a?(Numeric) or return Output::Failure(:invalid_arg, message: 'num2 must be numeric')
Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
Output::Success(:ok)
end
def divide(num1:, num2:)
Output::Success(:ok, number: num1 / num2)
end
end
module SumDivisionsByTwo
extend self
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Output::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
else
Output::Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
private
def divide_by_two(num)
Division.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.call('30', '20', '10')
result2 = SumDivisionsByTwo.call(30, '20', '10')
result3 = SumDivisionsByTwo.call(30, 20, '10')
result4 = SumDivisionsByTwo.call(30, 20, 10)
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
result2 = SumDivisionsByTwo.call(30, 20, 10)
assert_event_logs(result1, size: 8)
assert_event_logs(result2, size: 10)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
result2 = SumDivisionsByTwo.call(30, 20, '10')
assert_event_logs(result1, size: 10)
assert_event_logs(result2, size: 8)
end
end
end
solid-result-2.0.0/test/solid/output/event_logs/enabled/without_source/singleton/recursion_test.rb 0000664 0000000 0000000 00000002613 14606620746 0034026 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class Output::EventLogsEnabledWithoutSourceSingletonRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
module Fibonacci
extend self
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
fibonacci = number <= 1 ? number : call(number - 1).value[:number] + call(number - 2).value[:number]
Output::Success(:fibonacci, number: fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Output::Failure(:invalid_input, message: 'input must be numeric')
input.negative? and return Output::Failure(:negative_number, message: 'number cannot be negative')
Output::Success(:positive_number, number: input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.call('1')
failure2 = Fibonacci.call(-1)
fibonacci0 = Fibonacci.call(0)
fibonacci1 = Fibonacci.call(1)
fibonacci2 = Fibonacci.call(2)
assert_event_logs(failure1, size: 1)
assert_event_logs(failure2, size: 1)
assert_event_logs(fibonacci0, size: 2)
assert_event_logs(fibonacci1, size: 2)
assert_event_logs(fibonacci2, size: 6)
end
end
end
solid-result-2.0.0/test/solid/output/expectations/ 0000775 0000000 0000000 00000000000 14606620746 0022311 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/mixin_constants_test.rb 0000664 0000000 0000000 00000001513 14606620746 0027115 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::Expectations::MixinConstantsTest < Minitest::Test
class IncludingInClass
include Solid::Output::Expectations.mixin
end
module IncludingInModule
include Solid::Output::Expectations.mixin
end
class ExtendingInClass
extend Solid::Output::Expectations.mixin
end
module ExtendingInModule
extend Solid::Output::Expectations.mixin
end
test 'Solid::Output::Expectations.mixin sets a constant in all classes/modules' do
assert IncludingInClass.const_defined?(:ResultExpectationsMixin, false)
assert IncludingInModule.const_defined?(:ResultExpectationsMixin, false)
assert ExtendingInClass.const_defined?(:ResultExpectationsMixin, false)
assert ExtendingInModule.const_defined?(:ResultExpectationsMixin, false)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/ 0000775 0000000 0000000 00000000000 14606620746 0024644 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/failure/ 0000775 0000000 0000000 00000000000 14606620746 0026273 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/failure/type/ 0000775 0000000 0000000 00000000000 14606620746 0027254 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/failure/type/invalid_type_test.rb 0000664 0000000 0000000 00000002232 14606620746 0033326 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceFailureInvalidTypeTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err1, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:err, err: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call('10', 2)
end
assert_equal(
'type :err1 is not allowed. Allowed types: :err',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/failure/type_and_value/ 0000775 0000000 0000000 00000000000 14606620746 0031272 5 ustar 00root root 0000000 0000000 invalid_type_test.rb 0000664 0000000 0000000 00000002522 14606620746 0035267 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceFailureInvalidTypeAndValueTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
failure: {
err1: ->(value) { value.is_a?(Hash) && value[:message].is_a?(String) },
err2: ->(value) { value.is_a?(Hash) && value[:message].is_a?(String) }
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err1, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:err2, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
assert_equal(
'type :err is not allowed. Allowed types: :err1, :err2',
err.message
)
end
end
invalid_value_test.rb 0000664 0000000 0000000 00000002106 14606620746 0035420 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
failure: {
invalid_arg: ->(value) { value.is_a?(Hash) && value[:message].is_a?(String) },
division_by_zero: ->(value) { value.is_a?(Hash) && value[:message].is_a?(String) }
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: :'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: :'arg2 must be numeric')
return Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Success(:division_completed, number: (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, '2')
end
assert_equal(
'value {:message=>:"arg2 must be numeric"} is not allowed for :invalid_arg type',
err.message
)
end
end
pattern_matching_error_test.rb 0000664 0000000 0000000 00000002336 14606620746 0037343 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must not be zero')
return Failure(:division_by_zero, message: :'arg2 must not be zero') if arg2.zero?
Success(:division_completed, number: (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 0)
end
assert_match(
Regexp.new(
'value {:message=>:"arg2 must not be zero"} is not allowed for :division_by_zero type ' \
'\(.*arg2 must not be zero.*\)'
),
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/failure/type_and_value_test.rb 0000664 0000000 0000000 00000011344 14606620746 0032661 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceFailureTypeAndValueTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:invalid_arg)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:invalid_arg) { increment += 1 }
.on_failure(:division_by_zero) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:invalid_arg) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err3.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/failure/type_test.rb 0000664 0000000 0000000 00000007052 14606620746 0030644 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceFailureTypeTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:ok, **input) unless input[:number2].zero?
Failure(:err, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:ok, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:err)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:err) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:err) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.success(:err) { increment += 1 }
on.failure(:err) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :err',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:bar) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :bar is not allowed. Allowed types: :err',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :err',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :err',
err1.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :err',
err2.message
)
end
test 'does not handle all cases' do
err = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :err',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/failure/types/ 0000775 0000000 0000000 00000000000 14606620746 0027437 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/failure/types/invalid_type_test.rb 0000664 0000000 0000000 00000002260 14606620746 0033512 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceFailureInvalidTypesTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
failure: %i[err1 err2]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err1, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:err2, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
assert_equal(
'type :err is not allowed. Allowed types: :err1, :err2',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/failure/types_test.rb 0000664 0000000 0000000 00000012627 14606620746 0031033 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceFailureTypesTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:invalid_arg)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:invalid_arg) { increment += 1 }
.on_failure(:division_by_zero) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:invalid_arg) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :invalid_arg',
err4.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success/ 0000775 0000000 0000000 00000000000 14606620746 0026314 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success/type/ 0000775 0000000 0000000 00000000000 14606620746 0027275 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success/type/invalid_type_test.rb 0000664 0000000 0000000 00000001541 14606620746 0033351 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessInvalidTypeTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: :ok
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
return Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Success(:division_completed, number: arg1 / arg2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success/type_and_value/ 0000775 0000000 0000000 00000000000 14606620746 0031313 5 ustar 00root root 0000000 0000000 invalid_type_test.rb 0000664 0000000 0000000 00000001743 14606620746 0035314 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: {
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
return Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Success(:ok, number: arg1 / arg2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :ok is not allowed. Allowed types: :division_completed',
err.message
)
end
end
invalid_value_test.rb 0000664 0000000 0000000 00000001765 14606620746 0035453 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: {
division_completed: ->(value) {
value.is_a?(::Hash) && value[:number].is_a?(::Numeric)
}
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
return Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Success(:division_completed, number: (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
assert_equal(
'value {:number=>"5"} is not allowed for :division_completed type',
err.message
)
end
end
pattern_matching_error_test.rb 0000664 0000000 0000000 00000002074 14606620746 0037363 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: {
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
return Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Success(:division_completed, number: (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
assert_match(
Regexp.new(
'value {:number=>"5"} is not allowed for :division_completed type ' \
'\(.*5.*\)'
),
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success/type_and_value_test.rb 0000664 0000000 0000000 00000011251 14606620746 0032677 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessTypeAndValueTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: {
numbers: ->(value) {
case value
in { number1: Numeric, number2: Numeric } then true
end
},
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success/type_test.rb 0000664 0000000 0000000 00000006326 14606620746 0030670 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessTypeTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: :ok
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:ok, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:ok, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:ok)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:ok) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:ok) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:ok) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :ok',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :foo is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :ok',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :foo is not allowed. Allowed types: :ok',
err.message
)
end
test 'does not handle all cases' do
err = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :ok',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success/types/ 0000775 0000000 0000000 00000000000 14606620746 0027460 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success/types/invalid_type_test.rb 0000664 0000000 0000000 00000002266 14606620746 0033541 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessInvalidTypesTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: %i[ok1 ok2 ok3]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:ok1, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:ok2, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:ok, number: number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :ok is not allowed. Allowed types: :ok1, :ok2, :ok3',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success/types_test.rb 0000664 0000000 0000000 00000012503 14606620746 0031045 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessTypesTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: %i[numbers division_completed]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:numbers) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err4.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success_and_failure/ 0000775 0000000 0000000 00000000000 14606620746 0030645 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success_and_failure/mixed/ 0000775 0000000 0000000 00000000000 14606620746 0031753 5 ustar 00root root 0000000 0000000 type_and_value_with_types_test.rb 0000664 0000000 0000000 00000017011 14606620746 0040536 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success_and_failure/mixed # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: {
numbers: ->(value) {
case value
in { number1: Numeric, number2: Numeric } then true
end
},
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
},
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
types_with_type_and_value_test.rb 0000664 0000000 0000000 00000016766 14606620746 0040556 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success_and_failure/mixed # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: %i[numbers division_completed],
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
type_and_value_test.rb 0000664 0000000 0000000 00000017341 14606620746 0035157 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/with_source/success_and_failure # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: {
numbers: ->(value) {
case value
in { number1: Numeric, number2: Numeric } then true
end
},
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
},
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success_and_failure/type_test.rb 0000664 0000000 0000000 00000015161 14606620746 0033216 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypeTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: :ok,
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, message: 'arg2 must be numeric')
Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:ok, **input) unless input[:number2].zero?
Failure(:err, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:ok, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:ok)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:err)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:ok) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:err) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:ok) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:ok) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:err) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:err) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:division_completed)
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:division_by_zero)
end
assert_equal(
'type :division_by_zero is not allowed. Allowed types: :err',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:division_completed) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:invalid_arg) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :err',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :ok, :err',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:division_completed) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:division_by_zero) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :division_by_zero is not allowed. Allowed types: :err',
err2.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :ok, :err',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:ok) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:err) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:ok) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:err) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :err',
err1.message
)
assert_equal(
'You must handle all cases. This was not handled: :err',
err2.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err4.message
)
assert_equal(
'You must handle all cases. This was not handled: :err',
err5.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err6.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/with_source/success_and_failure/types_test.rb 0000664 0000000 0000000 00000016405 14606620746 0033403 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypesTest < Minitest::Test
class Divide
include Solid::Output::Expectations.mixin(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, message: 'arg2 must be numeric')
Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Success(:numbers, **input) unless input[:number2].zero?
Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/ 0000775 0000000 0000000 00000000000 14606620746 0025374 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/failure/ 0000775 0000000 0000000 00000000000 14606620746 0027023 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/failure/type/ 0000775 0000000 0000000 00000000000 14606620746 0030004 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/failure/type/invalid_type_test.rb 0000664 0000000 0000000 00000002361 14606620746 0034061 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceFailureInvalidTypeTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err1, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg2 must be numeric')
Result::Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:ok, number2: number2, **input) unless number2.zero?
Result::Failure(:err2, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:ok, number: number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call('10', 2)
end
assert_equal(
'type :err1 is not allowed. Allowed types: :err',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/failure/type_and_value/ 0000775 0000000 0000000 00000000000 14606620746 0032022 5 ustar 00root root 0000000 0000000 invalid_type_test.rb 0000664 0000000 0000000 00000002752 14606620746 0036024 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceFailureInvalidTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: {
err1: ->(value) {
case value
in { message: String } then true
end
},
err2: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err1, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg2 must be numeric')
Result::Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:ok, number2: number2, **input) unless number2.zero?
Result::Failure(:err2, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:ok, number: number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
assert_equal(
'type :err is not allowed. Allowed types: :err1, :err2',
err.message
)
end
end
invalid_value_test.rb 0000664 0000000 0000000 00000002366 14606620746 0036160 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: :'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: :'arg2 must be numeric')
return Result::Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, number: (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, '2')
end
assert_match(
Regexp.new(
'value {:message=>:\"arg2 must be numeric\"} is not allowed for :invalid_arg type ' \
'\(.*arg2 must be numeric.*\)'
),
err.message
)
end
end
pattern_matching_error_test.rb 0000664 0000000 0000000 00000002377 14606620746 0040100 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
return Result::Failure(:division_by_zero, message: :'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, number: (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 0)
end
assert_match(
Regexp.new(
'value {:message=>:"arg2 must not be zero"} is not allowed for :division_by_zero type ' \
'\(.*arg2 must not be zero.*\)'
),
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/failure/type_and_value_test.rb 0000664 0000000 0000000 00000011520 14606620746 0033405 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceFailureTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:numbers, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:invalid_arg)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:invalid_arg) { increment += 1 }
.on_failure(:division_by_zero) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:invalid_arg) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err3.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/failure/type_test.rb 0000664 0000000 0000000 00000007202 14606620746 0031371 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceFailureTypeTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg2 must be numeric')
Result::Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Result::Success(:ok, **input) unless input[:number2].zero?
Result::Failure(:err, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:ok, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:err)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:err) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:err) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.success(:err) { increment += 1 }
on.failure(:err) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :err',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:bar) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :bar is not allowed. Allowed types: :err',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :err',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :err',
err1.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :err',
err2.message
)
end
test 'does not handle all cases' do
err = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :err',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/failure/types/ 0000775 0000000 0000000 00000000000 14606620746 0030167 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/failure/types/invalid_type_test.rb 0000664 0000000 0000000 00000002372 14606620746 0034246 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceFailureInvalidTypesTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
failure: %i[err1 err2]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err1, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg2 must be numeric')
Result::Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:ok, number2: number2, **input) unless number2.zero?
Failure(:err2, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:ok, number: number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
assert_equal(
'type :err is not allowed. Allowed types: :err1, :err2',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/failure/types_test.rb 0000664 0000000 0000000 00000013003 14606620746 0031550 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceFailureTypesTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:numbers, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:invalid_arg)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:invalid_arg) { increment += 1 }
.on_failure(:division_by_zero) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:invalid_arg) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :invalid_arg',
err4.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success/ 0000775 0000000 0000000 00000000000 14606620746 0027044 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success/type/ 0000775 0000000 0000000 00000000000 14606620746 0030025 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success/type/invalid_type_test.rb 0000664 0000000 0000000 00000001603 14606620746 0034100 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessInvalidTypeTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: :ok
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
return Result::Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, number: arg1 / arg2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success/type_and_value/ 0000775 0000000 0000000 00000000000 14606620746 0032043 5 ustar 00root root 0000000 0000000 invalid_type_test.rb 0000664 0000000 0000000 00000002005 14606620746 0036034 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: {
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
return Result::Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Result::Success(:ok, number: arg1 / arg2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :ok is not allowed. Allowed types: :division_completed',
err.message
)
end
end
invalid_value_test.rb 0000664 0000000 0000000 00000002127 14606620746 0036174 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: {
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
return Result::Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, number: (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
assert_match(
Regexp.new(
'value {:number=>"5"} is not allowed for :division_completed type ' \
'\(.*5.*\)'
),
err.message
)
end
end
pattern_matching_error_test.rb 0000664 0000000 0000000 00000002151 14606620746 0040107 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: {
division_completed: ->(value) do
case value
in { number: Integer | Float } then true
end
end
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
return Result::Failure(:division_by_zero, message: 'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, number: (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
assert_match(
Regexp.new(
'value {:number=>"5"} is not allowed for :division_completed type ' \
'\(.*5.*\)'
),
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success/type_and_value_test.rb 0000664 0000000 0000000 00000011425 14606620746 0033432 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: {
numbers: ->(value) {
case value
in { number1: Numeric, number2: Numeric } then true
end
},
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:numbers, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success/type_test.rb 0000664 0000000 0000000 00000006502 14606620746 0031414 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessTypeTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: :ok
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:ok, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:ok, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:ok)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:ok) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:ok) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:ok) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :ok',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :foo is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :ok',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :foo is not allowed. Allowed types: :ok',
err.message
)
end
test 'does not handle all cases' do
err = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :ok',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success/types/ 0000775 0000000 0000000 00000000000 14606620746 0030210 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success/types/invalid_type_test.rb 0000664 0000000 0000000 00000002361 14606620746 0034265 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessInvalidTypesTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: %i[ok1 ok2 ok3]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg2 must be numeric')
Result::Success(:ok1, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Result::Success(:ok2, **input) unless input[:number2].zero?
Result::Failure(:err, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:ok, number: number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :ok is not allowed. Allowed types: :ok1, :ok2, :ok3',
err.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success/types_test.rb 0000664 0000000 0000000 00000012657 14606620746 0031607 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessTypesTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: %i[numbers division_completed]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:numbers, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:numbers) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err4.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success_and_failure/ 0000775 0000000 0000000 00000000000 14606620746 0031375 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success_and_failure/mixed/ 0000775 0000000 0000000 00000000000 14606620746 0032503 5 ustar 00root root 0000000 0000000 type_and_value_with_types_test.rb 0000664 0000000 0000000 00000017165 14606620746 0041300 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success_and_failure/mixed # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: {
numbers: ->(value) {
case value
in { number1: Numeric, number2: Numeric } then true
end
},
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
},
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:numbers, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
types_with_type_and_value_test.rb 0000664 0000000 0000000 00000017142 14606620746 0041273 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success_and_failure/mixed # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: %i[numbers division_completed],
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:numbers, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
type_and_value_test.rb 0000664 0000000 0000000 00000017515 14606620746 0035712 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/expectations/without_source/success_and_failure # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: {
numbers: ->(value) {
case value
in { number1: Numeric, number2: Numeric } then true
end
},
division_completed: ->(value) {
case value
in { number: Numeric } then true
end
}
},
failure: {
invalid_arg: ->(value) {
case value
in { message: String } then true
end
},
division_by_zero: ->(value) {
case value
in { message: String } then true
end
}
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:numbers, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success_and_failure/type_test.rb 0000664 0000000 0000000 00000015311 14606620746 0033743 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypeTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: :ok,
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, message: 'arg2 must be numeric')
Result::Success(:ok, number1: arg1, number2: arg2)
end
def validate_non_zero(**input)
return Result::Success(:ok, **input) unless input[:number2].zero?
Result::Failure(:err, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:ok, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:ok)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:err)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:ok) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:err) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:ok) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:ok) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:err) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:err) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:division_completed)
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:division_by_zero)
end
assert_equal(
'type :division_by_zero is not allowed. Allowed types: :err',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:division_completed) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:invalid_arg) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :err',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :ok, :err',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:division_completed) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:division_by_zero) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :division_by_zero is not allowed. Allowed types: :err',
err2.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :ok, :err',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:ok) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:err) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:ok) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:err) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :err',
err1.message
)
assert_equal(
'You must handle all cases. This was not handled: :err',
err2.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err4.message
)
assert_equal(
'You must handle all cases. This was not handled: :err',
err5.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err6.message
)
end
end
solid-result-2.0.0/test/solid/output/expectations/without_source/success_and_failure/types_test.rb 0000664 0000000 0000000 00000016561 14606620746 0034136 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypesTest < Minitest::Test
class Divide
Result = Solid::Output::Expectations.new(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |input| validate_non_zero(**input) }
.and_then { |input| divide(**input) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, message: 'arg2 must be numeric')
Result::Success(:numbers, number1: arg1, number2: arg2)
end
def validate_non_zero(number2:, **input)
return Result::Success(:numbers, number2: number2, **input) unless number2.zero?
Result::Failure(:division_by_zero, message: 'arg2 must not be zero')
end
def divide(number1:, number2:)
Result::Success(:division_completed, number: number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
solid-result-2.0.0/test/solid/output/failure_test.rb 0000664 0000000 0000000 00000000755 14606620746 0022625 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputFailureTest < Minitest::Test
test 'is a Solid::Output' do
assert Output::Failure < Solid::Output
end
test 'is a Solid::Failure' do
assert Output::Failure < Solid::Failure
end
test '#inspect' do
result = Output::Failure(:err, number: 0)
assert_equal(
'#0}>',
result.inspect
)
end
end
end
solid-result-2.0.0/test/solid/output/mixin_constants_test.rb 0000664 0000000 0000000 00000001307 14606620746 0024410 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::MixinConstantsTest < Minitest::Test
class IncludingInClass
include Solid::Output.mixin
end
module IncludingInModule
include Solid::Output.mixin
end
class ExtendingInClass
extend Solid::Output.mixin
end
module ExtendingInModule
extend Solid::Output.mixin
end
test 'Solid::Output.mixin sets a constant in all classes/modules' do
assert IncludingInClass.const_defined?(:ResultMixin, false)
assert IncludingInModule.const_defined?(:ResultMixin, false)
assert ExtendingInClass.const_defined?(:ResultMixin, false)
assert ExtendingInModule.const_defined?(:ResultMixin, false)
end
end
solid-result-2.0.0/test/solid/output/pattern_matching/ 0000775 0000000 0000000 00000000000 14606620746 0023132 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/output/pattern_matching/deconstruct_keys_test.rb 0000664 0000000 0000000 00000004131 14606620746 0030105 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::PatternMatchingDeconstructKeysTest < Minitest::Test
Divide = ->(arg1, arg2) do
arg1.is_a?(::Numeric) or return Solid::Output::Failure(:invalid_arg, err: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Solid::Output::Failure(:invalid_arg, err: 'arg2 must be numeric')
return Solid::Output::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
Solid::Output::Success(:division_completed, num: arg1 / arg2)
end
test '#deconstruct_keys success' do
result = Divide.call(10, 2)
assert_equal({ num: 5 }, result.deconstruct_keys([]))
case result
in Solid::Failure(type: _, value: _)
raise
in Solid::Success(type: :division_completed, value: { num: num })
assert_equal 5, num
end
case result
in Solid::Failure
raise
in Solid::Success(num: num)
assert_equal 5, num
end
case result
in Solid::Output::Failure(type: _, value: _)
raise
in Solid::Output::Success(type: :division_completed, value: { num: num })
assert_equal 5, num
end
case result
in Solid::Output::Failure
raise
in Solid::Output::Success(num: num)
assert_equal 5, num
end
end
test '#deconstruct_keys failure' do
result = Divide.call(10, 0)
assert_equal({ err: 'arg2 must not be zero' }, result.deconstruct_keys([]))
case result
in Solid::Success(type: _, value: _)
raise
in Solid::Failure(type: :division_by_zero, value: {err: msg})
assert_equal 'arg2 must not be zero', msg
end
case result
in Solid::Success
raise
in Solid::Failure(err: msg)
assert_equal 'arg2 must not be zero', msg
end
case result
in Solid::Output::Success(type: _, value: _)
raise
in Solid::Output::Failure(type: :division_by_zero, value: {err: msg})
assert_equal 'arg2 must not be zero', msg
end
case result
in Solid::Output::Success
raise
in Solid::Output::Failure(err: msg)
assert_equal 'arg2 must not be zero', msg
end
end
end
solid-result-2.0.0/test/solid/output/pattern_matching/deconstruct_test.rb 0000664 0000000 0000000 00000002737 14606620746 0027064 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Output::PatternMatchingDeconstructTest < Minitest::Test
Divide = ->(arg1, arg2) do
arg1.is_a?(::Numeric) or return Solid::Output::Failure(:invalid_arg, err: 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Solid::Output::Failure(:invalid_arg, err: 'arg2 must be numeric')
return Solid::Output::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
Solid::Output::Success(:division_completed, num: arg1 / arg2)
end
test '#deconstruct success' do
result = Divide.call(10, 2)
assert_equal [:division_completed, { num: 5 }], result.deconstruct
case result
in Solid::Failure[_, _]
raise
in Solid::Success[:division_completed, {num: value}]
assert_equal 5, value
end
case result
in Solid::Output::Failure[_, _]
raise
in Solid::Output::Success[:division_completed, {num: value}]
assert_equal 5, value
end
end
test '#deconstruct failure' do
result = Divide.call(10, 0)
assert_equal [:division_by_zero, { err: 'arg2 must not be zero' }], result.deconstruct
case result
in Solid::Success[_, _]
raise
in Solid::Failure[:division_by_zero, {err: msg}]
assert_equal 'arg2 must not be zero', msg
end
case result
in Solid::Output::Success[_, _]
raise
in Solid::Output::Failure[:division_by_zero, {err: msg}]
assert_equal 'arg2 must not be zero', msg
end
end
end
solid-result-2.0.0/test/solid/output/success_test.rb 0000664 0000000 0000000 00000005461 14606620746 0022645 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputSuccessTest < Minitest::Test
test 'is a Solid::Output' do
assert Output::Success < Solid::Output
end
test 'is a Solid::Success' do
assert Output::Success < Solid::Success
end
test '#inspect' do
result = Output::Success(:ok, number: 1)
assert_equal(
'#1}>',
result.inspect
)
end
test '#[]' do
result1 = Output::Success(:ok)
result2 = Output::Success(:ok, a: 1, b: 2)
assert_nil result1[:a]
assert_nil result1[:b]
assert_equal 1, result2[:a]
assert_equal 2, result2[:b]
end
# rubocop:disable Style/SingleArgumentDig
test '#dig' do
result1 = Output::Success(:ok)
result2 = Output::Success(:ok, a: { b: 1 })
assert_nil result1.dig(:a, :b)
assert_nil result2.dig(:a, :c)
assert_equal({ b: 1 }, result2.dig(:a))
assert_equal 1, result2.dig(:a, :b)
end
# rubocop:enable Style/SingleArgumentDig
test '#fetch' do
result1 = Output::Success(:ok)
result2 = Output::Success(:ok, a: 1, b: 2)
assert_raises(KeyError) { result1.fetch(:a) }
assert_raises(KeyError) { result1.fetch(:b) }
assert_equal 1, result2.fetch(:a)
assert_equal 2, result2.fetch(:b)
# ---
assert_equal 3, result1.fetch(:a, 3)
assert_equal 4, result1.fetch(:b, 4)
assert_equal 1, result2.fetch(:a, 3)
assert_equal 2, result2.fetch(:b, 4)
# ---
# rubocop:disable Style/RedundantFetchBlock
assert_equal(5, result1.fetch(:a) { 5 })
assert_equal(6, result1.fetch(:b) { 6 })
assert_equal(1, result2.fetch(:a) { 7 })
assert_equal(2, result2.fetch(:b) { 8 })
# rubocop:enable Style/RedundantFetchBlock
end
test '#slice' do
result1 = Output::Success(:ok)
result2 = Output::Success(:ok, a: 1, b: 2)
assert_equal({}, result1.slice(:a, :b))
assert_equal({ a: 1, b: 2 }, result2.slice(:a, :b))
end
test '#values_at' do
result1 = Output::Success(:ok)
result2 = Output::Success(:ok, a: 1, b: 2)
assert_equal [nil, nil], result1.values_at(:a, :b)
assert_equal [1, 2], result2.values_at(:a, :b)
end
test '#fetch_values' do
result1 = Output::Success(:ok)
result2 = Output::Success(:ok, a: 1, b: 2)
assert_raises(KeyError) do
result1.fetch_values(:a, :b)
end
assert_equal [1, 2], result2.fetch_values(:a, :b)
# ---
values1 = result1.fetch_values(:a, :b, :c, :d) { |key| key.to_s.upcase }
values2 = result2.fetch_values(:a, :b, :c, :d) { |key| key.to_s.upcase }
assert_equal %w[A B C D], values1
assert_equal [1, 2, 'C', 'D'], values2
end
end
end
solid-result-2.0.0/test/solid/output_test.rb 0000664 0000000 0000000 00000002427 14606620746 0021174 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class OutputTest < Minitest::Test
test 'is a Solid::Result' do
assert Output < Solid::Result
end
test '#initialize value validation' do
err = assert_raises(ArgumentError) { Output.new(type: :ok, value: nil) }
assert_equal 'value must be a Hash', err.message
end
test '::Success()' do
result = Output::Success(:ok)
assert_equal(:ok, result.type)
assert_equal({}, result.value)
# ---
result = Output::Success(:yes, number: 1)
assert_equal(:yes, result.type)
assert_equal({ number: 1 }, result.value)
# ---
err = assert_raises(ArgumentError) { Output::Success(:ok, nil) }
assert_equal 'wrong number of arguments (given 2, expected 1)', err.message
end
test '::Failure()' do
result = Output::Failure(:no)
assert_equal(:no, result.type)
assert_equal({}, result.value)
# ---
result = Output::Failure(:err, number: 0)
assert_equal(:err, result.type)
assert_equal({ number: 0 }, result.value)
# ---
err = assert_raises(ArgumentError) { Output::Failure(:ok, nil) }
assert_equal 'wrong number of arguments (given 2, expected 1)', err.message
end
end
end
solid-result-2.0.0/test/solid/result/ 0000775 0000000 0000000 00000000000 14606620746 0017561 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/addons/ 0000775 0000000 0000000 00000000000 14606620746 0021031 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/addons/continue/ 0000775 0000000 0000000 00000000000 14606620746 0022655 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/addons/continue/expectations_test.rb 0000664 0000000 0000000 00000023635 14606620746 0026760 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::AddonsContinueExpectationsTest < Minitest::Test
class DivideType
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :ok,
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:err, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:ok, number1 / number2)
end
end
class DivideTypes
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
module DivideTypeAndValue
extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: { division_completed: Numeric },
failure: { invalid_arg: String, division_by_zero: String }
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'method chaining using Continue' do
result1 = DivideType.new.call(10, 2)
result2 = DivideTypes.new.call(10, 2)
result3 = DivideTypeAndValue.call(10, 2)
assert result1.success?(:ok)
assert result2.success?(:division_completed)
assert result3.success?(:division_completed)
end
test 'type checking' do
success1 = DivideType.new.call(10, 2)
success2 = DivideTypes.new.call(10, 2)
success3 = DivideTypeAndValue.call(10, 2)
failure1 = DivideType.new.call('10', 0)
failure2 = DivideTypes.new.call('10', 0)
failure3 = DivideTypeAndValue.call('10', 0)
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { success1.success?(:division_completed) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { success2.success?(:ok) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { success3.success?(:ok) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { failure1.failure?(:invalid_arg) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { failure2.failure?(:err) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { failure3.failure?(:err) }
end
class InstanceFirstSuccessToTerminateTheStepChainAndThenBlock
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
def call
Success(:first)
.and_then { Continue(:second) }
.and_then { Continue(:third) }
end
end
class InstanceSecondSuccessToTerminateTheStepChainAndThenBlock
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
def call
Continue(:first)
.and_then { Success(:second) }
.and_then { Continue(:third) }
end
end
class InstanceThirdSuccessToTerminateTheStepChainAndThenBlock
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
def call
Continue(:first)
.and_then { Continue(:second) }
.and_then { Success(:third) }
end
end
module SingletonFirstSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
def call
Success(:first)
.and_then { Continue(:second) }
.and_then { Continue(:third) }
end
end
module SingletonSecondSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
def call
Continue(:first)
.and_then { Success(:second) }
.and_then { Continue(:third) }
end
end
module SingletonThirdSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
def call
Continue(:first)
.and_then { Continue(:second) }
.and_then { Success(:third) }
end
end
test 'the step chain termination (and_then block)' do
instance_result1 = InstanceFirstSuccessToTerminateTheStepChainAndThenBlock.new.call
instance_result2 = InstanceSecondSuccessToTerminateTheStepChainAndThenBlock.new.call
instance_result3 = InstanceThirdSuccessToTerminateTheStepChainAndThenBlock.new.call
singleton_result1 = SingletonFirstSuccessToTerminateTheStepChainAndThenBlock.call
singleton_result2 = SingletonSecondSuccessToTerminateTheStepChainAndThenBlock.call
singleton_result3 = SingletonThirdSuccessToTerminateTheStepChainAndThenBlock.call
assert(instance_result1.success?(:first) && instance_result1.terminal?)
assert(instance_result2.success?(:second) && instance_result2.terminal?)
assert(instance_result3.success?(:third) && instance_result3.terminal?)
assert(singleton_result1.success?(:first) && singleton_result1.terminal?)
assert(singleton_result2.success?(:second) && singleton_result2.terminal?)
assert(singleton_result3.success?(:third) && singleton_result3.terminal?)
end
class InstanceFirstSuccessToTerminateTheStepChainAndThenMethod
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Success(:first); end
def second_success; Continue(:second); end
def third_success; Continue(:third); end
end
class InstanceSecondSuccessToTerminateTheStepChainAndThenMethod
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(:first); end
def second_success; Success(:second); end
def third_success; Continue(:third); end
end
class InstanceThirdSuccessToTerminateTheStepChainAndThenMethod
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(:first); end
def second_success; Continue(:second); end
def third_success; Success(:third); end
end
module SingletonFirstSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Success(:first); end
def second_success; Continue(:second); end
def third_success; Continue(:third); end
end
module SingletonSecondSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(:first); end
def second_success; Success(:second); end
def third_success; Continue(:third); end
end
module SingletonThirdSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(:first); end
def second_success; Continue(:second); end
def third_success; Success(:third); end
end
test 'the step chain termination (and_then calling a method)' do
instance_result1 = InstanceFirstSuccessToTerminateTheStepChainAndThenMethod.new.call
instance_result2 = InstanceSecondSuccessToTerminateTheStepChainAndThenMethod.new.call
instance_result3 = InstanceThirdSuccessToTerminateTheStepChainAndThenMethod.new.call
assert(instance_result1.success?(:first) && instance_result1.terminal?)
assert(instance_result2.success?(:second) && instance_result2.terminal?)
assert(instance_result3.success?(:third) && instance_result3.terminal?)
end
end
solid-result-2.0.0/test/solid/result/addons/continue/instance_test.rb 0000664 0000000 0000000 00000010642 14606620746 0026050 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::AddonsContinueInstanceTest < Minitest::Test
class Divide
include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'method chaining using Continue' do
success = Divide.new.call(10, 2)
failure1 = Divide.new.call('10', 0)
failure2 = Divide.new.call(10, '2')
failure3 = Divide.new.call(10, 0)
assert_predicate success, :success?
assert_equal :division_completed, success.type
assert_equal 5, success.value
assert_predicate failure1, :failure?
assert_equal :invalid_arg, failure1.type
assert_equal 'arg1 must be numeric', failure1.value
assert_predicate failure2, :failure?
assert_equal :invalid_arg, failure2.type
assert_equal 'arg2 must be numeric', failure2.value
assert_predicate failure3, :failure?
assert_equal :division_by_zero, failure3.type
assert_equal 'arg2 must not be zero', failure3.value
end
class FirstSuccessToTerminateTheStepChainAndThenBlock
include Solid::Result.mixin(config: { addon: { continue: true } })
def call
Success(:first)
.and_then { Continue(:second) }
.and_then { Continue(:third) }
end
end
class SecondSuccessToTerminateTheStepChainAndThenBlock
include Solid::Result.mixin(config: { addon: { continue: true } })
def call
Continue(:first)
.and_then { Success(:second) }
.and_then { Continue(:third) }
end
end
class ThirdSuccessToTerminateTheStepChainAndThenBlock
include Solid::Result.mixin(config: { addon: { continue: true } })
def call
Continue(:first)
.and_then { Continue(:second) }
.and_then { Success(:third) }
end
end
test 'the step chain termination (and_then block)' do
result1 = FirstSuccessToTerminateTheStepChainAndThenBlock.new.call
result2 = SecondSuccessToTerminateTheStepChainAndThenBlock.new.call
result3 = ThirdSuccessToTerminateTheStepChainAndThenBlock.new.call
assert(result1.success?(:first) && result1.terminal?)
assert(result2.success?(:second) && result2.terminal?)
assert(result3.success?(:third) && result3.terminal?)
end
class FirstSuccessToTerminateTheStepChainAndThenMethod
include Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Success(:first); end
def second_success; Continue(:second); end
def third_success; Continue(:third); end
end
class SecondSuccessToTerminateTheStepChainAndThenMethod
include Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(:first); end
def second_success; Success(:second); end
def third_success; Continue(:third); end
end
class ThirdSuccessToTerminateTheStepChainAndThenMethod
include Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(:first); end
def second_success; Continue(:second); end
def third_success; Success(:third); end
end
test 'the step chain termination (and_then calling a method)' do
result1 = FirstSuccessToTerminateTheStepChainAndThenMethod.new.call
result2 = SecondSuccessToTerminateTheStepChainAndThenMethod.new.call
result3 = ThirdSuccessToTerminateTheStepChainAndThenMethod.new.call
assert(result1.success?(:first) && result1.terminal?)
assert(result2.success?(:second) && result2.terminal?)
assert(result3.success?(:third) && result3.terminal?)
end
end
solid-result-2.0.0/test/solid/result/addons/continue/singleton_test.rb 0000664 0000000 0000000 00000010645 14606620746 0026251 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::AddonsContinueSingletonTest < Minitest::Test
module Divide
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'method chaining using Continue' do
success = Divide.call(10, 2)
failure1 = Divide.call('10', 0)
failure2 = Divide.call(10, '2')
failure3 = Divide.call(10, 0)
assert_predicate success, :success?
assert_equal :division_completed, success.type
assert_equal 5, success.value
assert_predicate failure1, :failure?
assert_equal :invalid_arg, failure1.type
assert_equal 'arg1 must be numeric', failure1.value
assert_predicate failure2, :failure?
assert_equal :invalid_arg, failure2.type
assert_equal 'arg2 must be numeric', failure2.value
assert_predicate failure3, :failure?
assert_equal :division_by_zero, failure3.type
assert_equal 'arg2 must not be zero', failure3.value
end
module FirstSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
Success(:first)
.and_then { Continue(:second) }
.and_then { Continue(:third) }
end
end
module SecondSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
Continue(:first)
.and_then { Success(:second) }
.and_then { Continue(:third) }
end
end
module ThirdSuccessToTerminateTheStepChainAndThenBlock
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
Continue(:first)
.and_then { Continue(:second) }
.and_then { Success(:third) }
end
end
test 'the step chain termination (and_then block)' do
result1 = FirstSuccessToTerminateTheStepChainAndThenBlock.call
result2 = SecondSuccessToTerminateTheStepChainAndThenBlock.call
result3 = ThirdSuccessToTerminateTheStepChainAndThenBlock.call
assert(result1.success?(:first) && result1.terminal?)
assert(result2.success?(:second) && result2.terminal?)
assert(result3.success?(:third) && result3.terminal?)
end
module FirstSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Success(:first); end
def second_success; Continue(:second); end
def third_success; Continue(:third); end
end
module SecondSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(:first); end
def second_success; Success(:second); end
def third_success; Continue(:third); end
end
module ThirdSuccessToTerminateTheStepChainAndThenMethod
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
.and_then(:second_success)
.and_then(:third_success)
end
private
def first_success; Continue(:first); end
def second_success; Continue(:second); end
def third_success; Success(:third); end
end
test 'the step chain termination (and_then calling a method)' do
result1 = FirstSuccessToTerminateTheStepChainAndThenMethod.call
result2 = SecondSuccessToTerminateTheStepChainAndThenMethod.call
result3 = ThirdSuccessToTerminateTheStepChainAndThenMethod.call
assert(result1.success?(:first) && result1.terminal?)
assert(result2.success?(:second) && result2.terminal?)
assert(result3.success?(:third) && result3.terminal?)
end
end
solid-result-2.0.0/test/solid/result/addons/given/ 0000775 0000000 0000000 00000000000 14606620746 0022141 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/addons/given/expectations_test.rb 0000664 0000000 0000000 00000005770 14606620746 0026244 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::AddonsGivenExpectationsTest < Minitest::Test
class DivideType
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :ok,
failure: :err
)
def call(arg1, arg2)
Given([arg1, arg2])
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(numbers)
number1, number2 = numbers
number1.is_a?(::Numeric) or return Failure(:err, 'arg1 must be numeric')
number2.is_a?(::Numeric) or return Failure(:err, 'arg2 must be numeric')
Continue(numbers)
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:err, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:ok, number1 / number2)
end
end
class DivideTypes
include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
Given([arg1, arg2])
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers((arg1, arg2))
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
module DivideTypeAndValue
extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: { division_completed: Numeric },
failure: { invalid_arg: String, division_by_zero: String }
)
def call(arg1, arg2)
Given([arg1, arg2])
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers((arg1, arg2))
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'method chaining' do
result1 = DivideType.new.call(10, 2)
result2 = DivideTypes.new.call(10, 2)
result3 = DivideTypeAndValue.call(10, 2)
assert result1.success?(:ok)
assert result2.success?(:division_completed)
assert result3.success?(:division_completed)
end
end
solid-result-2.0.0/test/solid/result/addons/given/instance_test.rb 0000664 0000000 0000000 00000003147 14606620746 0025336 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::AddonsGivenInstanceTest < Minitest::Test
class Divide
include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given([arg1, arg2])
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers((arg1, arg2))
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'method chaining' do
success = Divide.new.call(10, 2)
failure1 = Divide.new.call('10', 0)
failure2 = Divide.new.call(10, '2')
failure3 = Divide.new.call(10, 0)
assert_predicate success, :success?
assert_equal :division_completed, success.type
assert_equal 5, success.value
assert_predicate failure1, :failure?
assert_equal :invalid_arg, failure1.type
assert_equal 'arg1 must be numeric', failure1.value
assert_predicate failure2, :failure?
assert_equal :invalid_arg, failure2.type
assert_equal 'arg2 must be numeric', failure2.value
assert_predicate failure3, :failure?
assert_equal :division_by_zero, failure3.type
assert_equal 'arg2 must not be zero', failure3.value
end
end
solid-result-2.0.0/test/solid/result/addons/given/singleton_test.rb 0000664 0000000 0000000 00000003155 14606620746 0025533 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::AddonsGivenSingletonTest < Minitest::Test
module Divide
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given([arg1, arg2])
.and_then(:validate_numbers)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers((arg1, arg2))
arg1.is_a?(Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Continue([arg1, arg2])
end
def validate_non_zero(numbers)
return Continue(numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'method chaining using Continue' do
success = Divide.call(10, 2)
failure1 = Divide.call('10', 0)
failure2 = Divide.call(10, '2')
failure3 = Divide.call(10, 0)
assert_predicate success, :success?
assert_equal :division_completed, success.type
assert_equal 5, success.value
assert_predicate failure1, :failure?
assert_equal :invalid_arg, failure1.type
assert_equal 'arg1 must be numeric', failure1.value
assert_predicate failure2, :failure?
assert_equal :invalid_arg, failure2.type
assert_equal 'arg2 must be numeric', failure2.value
assert_predicate failure3, :failure?
assert_equal :division_by_zero, failure3.type
assert_equal 'arg2 must not be zero', failure3.value
end
end
solid-result-2.0.0/test/solid/result/and_then/ 0000775 0000000 0000000 00000000000 14606620746 0021341 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/and_then/argument_error_test.rb 0000664 0000000 0000000 00000001156 14606620746 0025763 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class AndThenArgumentErrorTest < Minitest::Test
module SomeModule
extend Solid::Result.mixin
def self.call(arg1, arg2)
Success(:ok, arg1 + arg2)
.and_then(:some_method_name) { :method_name_and_block_are_not_allowed }
end
end
test 'raises ArgumentError when the method name and block are both given' do
error = assert_raises(ArgumentError) { SomeModule.call(1, 2) }
assert_equal(
'method_name and block are mutually exclusive',
error.message
)
end
end
end
solid-result-2.0.0/test/solid/result/and_then/with_source_test.rb 0000664 0000000 0000000 00000013123 14606620746 0025260 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class AndThenWithSourceTest < Minitest::Test
class Base
include Solid::Result.mixin
attr_reader :arg1, :arg2
def initialize(arg1, arg2)
@arg1 = arg1
@arg2 = arg2
end
def call; end
private
def validate_numbers
return Success(:ok) if arg1.is_a?(::Numeric) && arg2.is_a?(::Numeric)
Failure(:invalid_arg, 'both arguments must be numeric')
end
end
class SourceMethodArityWithArityZero < Base
def call
validate_numbers.and_then(:add)
end
private
def add
Success(:number, arg1 + arg2)
end
end
class SourceMethodArityWithArityOne < Base
def call
validate_numbers
.and_then { Success(:ok, [arg1, arg2]) }
.and_then(:add)
end
def add((number1, number2))
Success(:number, number1 + number2)
end
end
class SourceMethodArityWithArityTwo < Base
def call
context = { number: 3 }
validate_numbers
.and_then { Success(:ok, [arg1, arg2]) }
.and_then(:add, context)
end
def add((number1, number2), context)
Success(:number, number1 + number2 + context.fetch(:number))
end
end
class InvalidSourceMethodArity < Base
def call
validate_numbers.and_then(:add)
end
def add(number1, number2, _number3)
Success(:number, number1 + number2)
end
end
class InvalidResultSourceFromBlock < Base
def add_instance
@add_instance ||= SourceMethodArityWithArityZero.new(arg1, arg2)
end
def call
validate_numbers.and_then { add_instance.call }
end
end
class InvalidResultSourceFromMethod < Base
def add_instance
@add_instance ||= SourceMethodArityWithArityZero.new(arg1, arg2)
end
def call
validate_numbers.and_then(:add)
end
def add
add_instance.call
end
end
class UnexpectedBlockOutcome < Base
def call
validate_numbers.and_then { arg1 + arg2 }
end
end
class UnexpectedMethodOutcome < Base
def call
validate_numbers.and_then(:add)
end
def add
arg1 + arg2
end
end
test '#and_then calling a source method (arity 0)' do
result = SourceMethodArityWithArityZero.new(1, 2).call
assert_predicate(result, :success?)
assert_equal(:number, result.type)
assert_equal(3, result.value)
end
test '#and_then calling a source method (arity 1)' do
result = SourceMethodArityWithArityOne.new(1, 2).call
assert_predicate(result, :success?)
assert_equal(:number, result.type)
assert_equal(3, result.value)
end
test '#and_then calling a source method (arity 2)' do
result = SourceMethodArityWithArityTwo.new(1, 2).call
assert_predicate(result, :success?)
assert_equal(:number, result.type)
assert_equal(6, result.value)
end
test '#and_then calling a source method with wrong arity (> 2)' do
wrong_source_method_arity = InvalidSourceMethodArity.new(1, 2)
error = assert_raises(Solid::Result::Error::InvalidSourceMethodArity) { wrong_source_method_arity.call }
expected_message = "#{InvalidSourceMethodArity}#add has unsupported arity (3). Expected 0..2"
assert_equal(expected_message, error.message)
end
test '#and_then raises an error when the block returns a result that does not belongs to the source' do
wrong_result_source = InvalidResultSourceFromBlock.new(1, 2)
error = assert_raises(Solid::Result::Error::InvalidResultSource) { wrong_result_source.call }
expected_message =
"You cannot call #and_then and return a result that does not belong to the same source!\n" \
"Expected source: #{wrong_result_source.inspect}\n" \
"Given source: #{wrong_result_source.add_instance.inspect}\n" \
'Given result: #'
assert_equal(expected_message, error.message)
end
test '#and_then raises an error when the called method returns a result that does not belongs to the source' do
wrong_result_source = InvalidResultSourceFromMethod.new(1, 2)
error = assert_raises(Solid::Result::Error::InvalidResultSource) { wrong_result_source.call }
expected_message =
"You cannot call #and_then and return a result that does not belong to the same source!\n" \
"Expected source: #{wrong_result_source.inspect}\n" \
"Given source: #{wrong_result_source.add_instance.inspect}\n" \
'Given result: #'
assert_equal(expected_message, error.message)
end
test '#and_then raises an error when the block returns a non-result object' do
error = assert_raises(Solid::Result::Error::UnexpectedOutcome) { UnexpectedBlockOutcome.new(1, 2).call }
expected_message =
'Unexpected outcome: 3. The block must return this object wrapped by ' \
'Solid::Result::Success or Solid::Result::Failure'
assert_equal(expected_message, error.message)
end
test '#and_then raises an error when the method returns a non-result object' do
error = assert_raises(Solid::Result::Error::UnexpectedOutcome) { UnexpectedMethodOutcome.new(1, 2).call }
expected_message =
'Unexpected outcome: 3. The method must return this object wrapped by ' \
'Solid::Result::Success or Solid::Result::Failure'
assert_equal(expected_message, error.message)
end
end
end
solid-result-2.0.0/test/solid/result/and_then/without_source_test.rb 0000664 0000000 0000000 00000003365 14606620746 0026017 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class AndThenWithoutSourceTest < Minitest::Test
test '#and_then does not execute the block if the result is a failure' do
result =
Success
.new(type: :one, value: 1)
.and_then { Failure.new(type: :two, value: 2) }
.and_then { Success.new(type: :three, value: 3) }
.and_then { Success.new(type: :four, value: 4) }
assert_predicate result, :failure?
assert_equal :two, result.type
assert_equal 2, result.value
end
test '#and_then executes the block if the result is a success' do
result =
Success
.new(type: :one, value: 1)
.and_then { Success.new(type: :two, value: 2) }
.and_then { Success.new(type: :three, value: 3) }
.and_then { Success.new(type: :four, value: 4) }
assert_predicate result, :success?
assert_equal :four, result.type
assert_equal 4, result.value
end
test '#and_then does not handle an exception raised in the block' do
assert_raises(RuntimeError) do
Success
.new(type: :one, value: 1)
.and_then { Success.new(type: :two, value: 2) }
.and_then { raise 'boom' }
end
end
test '#and_then raises an exception if the block does not return a result' do
error = assert_raises(Solid::Result::Error::UnexpectedOutcome) do
Success
.new(type: :one, value: 1)
.and_then { Success.new(type: :two, value: 2) }
.and_then { 3 }
end
assert_equal(
'Unexpected outcome: 3. The block must return this object wrapped by ' \
'Solid::Result::Success or Solid::Result::Failure',
error.message
)
end
end
end
solid-result-2.0.0/test/solid/result/callable_and_then/ 0000775 0000000 0000000 00000000000 14606620746 0023160 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/callable_and_then/arity_test.rb 0000664 0000000 0000000 00000007563 14606620746 0025707 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class CallableAndThenArityTest < Minitest::Test
ProcWithoutArg = proc { Solid::Result::Success(:ok, -1) }
ProcWithOneArg = proc { |arg| Solid::Result::Success(:ok, arg) }
ProcWithTwoArgs = proc { |arg1, arg2| Solid::Result::Success(:ok, [arg1, arg2]) }
ProcWithThreeArgs = proc { |arg1, arg2, arg3| Solid::Result::Success(:ok, [arg1, arg2, arg3]) }
LambdaWithoutArg = -> { Solid::Result::Success(:ok, -1) }
LambdaWithOneArg = ->(arg) { Solid::Result::Success(:ok, arg) }
LambdaWithTwoArgs = ->(arg1, arg2) { Solid::Result::Success(:ok, [arg1, arg2]) }
LambdaWithThreeArgs = ->(arg1, arg2, arg3) { Solid::Result::Success(:ok, [arg1, arg2, arg3]) }
module ModWithoutArg
def self.call; Solid::Result::Success(:ok, -1); end
end
module ModWithOneArg
def self.call(arg); Solid::Result::Success(:ok, arg); end
end
module ModWithTwoArgs
def self.call(arg1, arg2); Solid::Result::Success(:ok, [arg1, arg2]); end
end
module ModWithThreeArgs
def self.call(arg1, arg2, arg3); Solid::Result::Success(:ok, [arg1, arg2, arg3]); end
end
def setup
Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
Solid::Result.config.feature.disable!(:and_then!)
end
test 'arity zero' do
err1 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Solid::Result::Success(:ok, 0).and_then!(ProcWithoutArg)
end
err2 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Solid::Result::Success(:ok, 0).and_then!(LambdaWithoutArg)
end
err3 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Solid::Result::Success(:ok, 0).and_then!(ModWithoutArg)
end
assert_equal 'Invalid arity for Proc#call method. Expected arity: 1..2', err1.message
assert_equal 'Invalid arity for Proc#call method. Expected arity: 1..2', err2.message
assert_equal 'Invalid arity for Module#call method. Expected arity: 1..2', err3.message
end
test 'arity one' do
result1 = Solid::Result::Success(:ok, 1).and_then!(ProcWithOneArg)
result2 = Solid::Result::Success(:ok, 2).and_then!(LambdaWithOneArg)
result3 = Solid::Result::Success(:ok, 3).and_then!(ModWithOneArg)
assert(result1.success?(:ok))
assert_equal 1, result1.value
assert(result2.success?(:ok))
assert_equal 2, result2.value
assert(result3.success?(:ok))
assert_equal 3, result3.value
end
test 'arity two' do
result1 = Solid::Result::Success(:ok, 1).and_then!(ProcWithTwoArgs, 2)
result2 = Solid::Result::Success(:ok, 2).and_then!(LambdaWithTwoArgs, 3)
result3 = Solid::Result::Success(:ok, 3).and_then!(ModWithTwoArgs, 4)
assert(result1.success?(:ok))
assert_equal [1, 2], result1.value
assert(result2.success?(:ok))
assert_equal [2, 3], result2.value
assert(result3.success?(:ok))
assert_equal [3, 4], result3.value
end
test 'arity greater than or equal to three' do
err1 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Solid::Result::Success(:ok, 0).and_then!(ProcWithThreeArgs, 1)
end
err2 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Solid::Result::Success(:ok, 0).and_then!(LambdaWithThreeArgs, 1)
end
err3 = assert_raises(Solid::Result::CallableAndThen::Error::InvalidArity) do
Solid::Result::Success(:ok, 0).and_then!(ModWithThreeArgs, 1)
end
assert_equal 'Invalid arity for Proc#call method. Expected arity: 1..2', err1.message
assert_equal 'Invalid arity for Proc#call method. Expected arity: 1..2', err2.message
assert_equal 'Invalid arity for Module#call method. Expected arity: 1..2', err3.message
end
end
end
solid-result-2.0.0/test/solid/result/callable_and_then/results_from_different_sources_test.rb 0000664 0000000 0000000 00000011742 14606620746 0033066 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class CallableAndThenResultFromDifferentSourcesTest < Minitest::Test
include SolidResultEventLogAssertions
module NormalizeEmail
extend Solid::Result.mixin
def self.call(input)
Solid::Result.event_logs(name: 'NormalizeEmail') do
Given(input).and_then(:normalize)
end
end
def self.normalize(input)
input.is_a?(::String) or return Failure(:invalid_input, 'input must be a String')
Success(:normalized_input, input.downcase.strip)
end
end
class EmailValidation
include Solid::Result.mixin
def initialize(expected_pattern: /\A[^@\s]+@[^@\s]+\z/)
@expected_pattern = expected_pattern
end
def call(input)
Solid::Result.event_logs(name: 'EmailValidation') do
Given(input).and_then(:validate)
end
end
def validate(input)
input.match?(@expected_pattern) ? Success(:valid_email, input) : Failure(:invalid_email, input)
end
end
module NormalizeAndValidateEmail
extend Solid::Result.mixin
def self.call(email)
Solid::Result.event_logs(name: 'NormalizeAndValidateEmail') do
Given(email)
.and_then!(NormalizeEmail)
.and_then!(EmailValidation.new)
end
end
end
def setup
Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
Solid::Result.config.feature.disable!(:and_then!)
end
test 'results from different sources' do
result1 = NormalizeAndValidateEmail.call(nil)
result2 = NormalizeAndValidateEmail.call(' ')
result3 = NormalizeAndValidateEmail.call(" FOO@bAr.com \n")
assert(result1.failure?(:invalid_input))
assert_equal('input must be a String', result1.value)
assert(result2.failure?(:invalid_email))
assert_equal('', result2.value)
assert(result3.success?(:valid_email))
assert_equal('foo@bar.com', result3.value)
end
test 'the event_logs tracking' do
result1 = NormalizeAndValidateEmail.call(1)
assert_event_logs(result1, size: 3)
assert_equal([0, [[1, []]]], result1.event_logs[:metadata][:ids][:tree])
root = { id: 0, name: 'NormalizeAndValidateEmail', desc: nil }
source = -> { _1 == NormalizeAndValidateEmail }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :_given_, value: 1, source: source }
}.then { assert_event_log_record(result1, 0, _1) }
source = -> { _1 == NormalizeEmail }
{
root: root,
parent: root,
current: { id: 1, name: 'NormalizeEmail', desc: nil },
result: { kind: :success, type: :_given_, value: 1, source: source }
}.then { assert_event_log_record(result1, 1, _1) }
{
root: root,
parent: root,
current: { id: 1, name: 'NormalizeEmail', desc: nil },
result: { kind: :failure, type: :invalid_input, value: 'input must be a String', source: source },
and_then: { type: :method, arg: nil, method_name: :normalize }
}.then { assert_event_log_record(result1, 2, _1) }
# ---
result2 = NormalizeAndValidateEmail.call(" FOO@bAr.com \n")
assert_event_logs(result2, size: 5)
assert_equal([0, [[1, []], [2, []]]], result2.event_logs[:metadata][:ids][:tree])
root = { id: 0, name: 'NormalizeAndValidateEmail', desc: nil }
source = -> { _1 == NormalizeAndValidateEmail }
{
root: root,
parent: root,
current: root,
result: { kind: :success, type: :_given_, value: " FOO@bAr.com \n", source: source }
}.then { assert_event_log_record(result2, 0, _1) }
source = -> { _1 == NormalizeEmail }
{
root: root,
parent: root,
current: { id: 1, name: 'NormalizeEmail', desc: nil },
result: { kind: :success, type: :_given_, value: " FOO@bAr.com \n", source: source }
}.then { assert_event_log_record(result2, 1, _1) }
{
root: root,
parent: root,
current: { id: 1, name: 'NormalizeEmail', desc: nil },
result: { kind: :success, type: :normalized_input, value: 'foo@bar.com', source: source },
and_then: { type: :method, arg: nil, method_name: :normalize }
}.then { assert_event_log_record(result2, 2, _1) }
{
root: root,
parent: root,
current: { id: 2, name: 'EmailValidation', desc: nil },
result: { kind: :success, type: :_given_, value: 'foo@bar.com', source: EmailValidation }
}.then { assert_event_log_record(result2, 3, _1) }
{
root: root,
parent: root,
current: { id: 2, name: 'EmailValidation', desc: nil },
result: { kind: :success, type: :valid_email, value: 'foo@bar.com', source: EmailValidation },
and_then: { type: :method, arg: nil, method_name: :validate }
}.then { assert_event_log_record(result2, 4, _1) }
end
end
end
solid-result-2.0.0/test/solid/result/callable_and_then/returning_an_output_test.rb 0000664 0000000 0000000 00000002746 14606620746 0030670 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class CallableAndThenReturninAnOutputTest < Minitest::Test
include SolidResultEventLogAssertions
module NormalizeEmail
extend ::Solid::Output.mixin
def self.call(arg)
Solid::Result.event_logs(name: 'NormalizeEmail') do
input = arg[:input]
input.is_a?(::String) or return Failure(:invalid_input, message: 'input must be a String')
Success(:normalized_input, input: input.downcase.strip)
end
end
end
module EmailNormalization
extend Solid::Result.mixin
def self.call(input)
Solid::Result.event_logs(name: 'EmailNormalization') do
Given(input: input)
.and_then!(NormalizeEmail)
end
end
end
test 'results from different sources' do
Solid::Result.config.feature.enable!(:and_then!)
result1 = EmailNormalization.call(nil)
assert_event_logs(result1, size: 2)
assert(result1.failure?(:invalid_input))
assert_equal({ message: 'input must be a String' }, result1.value)
assert_kind_of(::Solid::Output, result1)
result2 = EmailNormalization.call(' foo@BAR.com')
assert_event_logs(result1, size: 2)
assert(result2.success?(:normalized_input))
assert_equal({ input: 'foo@bar.com' }, result2.value)
assert_kind_of(::Solid::Output, result2)
ensure
Solid::Result.config.feature.disable!(:and_then!)
end
end
end
solid-result-2.0.0/test/solid/result/callable_and_then/unexpected_outcome_test.rb 0000664 0000000 0000000 00000002202 14606620746 0030437 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class CallableAndThenUnexpectedOutcomeTest < Minitest::Test
ProcWithArg = proc { |arg| arg }
module ModWithArg
def self.call(arg); arg; end
end
def setup
Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
Solid::Result.config.feature.disable!(:and_then!)
end
test 'unexpected outcome' do
err1 = assert_raises(Solid::Result::CallableAndThen::Error::UnexpectedOutcome) do
Solid::Result::Success(:ok, 0).and_then!(ProcWithArg)
end
err2 = assert_raises(Solid::Result::CallableAndThen::Error::UnexpectedOutcome) do
Solid::Result::Success(:ok, 0).and_then!(ModWithArg)
end
expected_kinds = 'Solid::Result::Success or Solid::Result::Failure'
assert_match(
/Unexpected outcome: 0. The # must return this object wrapped by #{expected_kinds}/,
err1.message
)
assert_match(
/Unexpected outcome: 0. The .+::ModWithArg must return this object wrapped by #{expected_kinds}/,
err2.message
)
end
end
end
solid-result-2.0.0/test/solid/result/config/ 0000775 0000000 0000000 00000000000 14606620746 0021026 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/config/addon/ 0000775 0000000 0000000 00000000000 14606620746 0022113 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/config/addon/continue_test.rb 0000664 0000000 0000000 00000013314 14606620746 0025325 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class AddonContinueTest < Minitest::Test
test 'the side effects' do
Solid::Result.config.addon.disable!(:continue)
class1a = Class.new do
include Solid::Result.mixin
def call
Continue("this method won't exist as the default config is disabled")
end
end
class2a = Class.new do
include Solid::Result::Expectations.mixin
def call
Continue("this method won't exist as the default config is disabled")
end
end
class3a = Class.new do
include Solid::Output.mixin
def call
Continue(msg: "this method won't exist as the default config is disabled")
end
end
class4a = Class.new do
include Solid::Output::Expectations.mixin
def call
Continue(msg: "this method won't exist as the default config is disabled")
end
end
error1a = assert_raises(NoMethodError) { class1a.new.call }
error2a = assert_raises(NoMethodError) { class2a.new.call }
error3a = assert_raises(NoMethodError) { class3a.new.call }
error4a = assert_raises(NoMethodError) { class4a.new.call }
assert_match(/undefined method.+Continue/, error1a.message)
assert_match(/undefined method.+Continue/, error2a.message)
assert_match(/undefined method.+Continue/, error3a.message)
assert_match(/undefined method.+Continue/, error4a.message)
Solid::Result.config.addon.enable!(:continue)
class1b = Class.new do
include Solid::Result.mixin
def call
Continue('this method will exist as the config is enabled by default')
end
end
class2b = Class.new do
include Solid::Result::Expectations.mixin
def call
Continue('this method will exist as the config is enabled by default')
end
end
class3b = Class.new do
include Solid::Output.mixin
def call
Continue(msg: 'this method will exist as the config is enabled by default')
end
end
class4b = Class.new do
include Solid::Output::Expectations.mixin
def call
Continue(msg: 'this method will exist as the config is enabled by default')
end
end
assert_equal('this method will exist as the config is enabled by default', class1b.new.call.value)
assert_equal('this method will exist as the config is enabled by default', class2b.new.call.value)
assert_equal('this method will exist as the config is enabled by default', class3b.new.call.value[:msg])
assert_equal('this method will exist as the config is enabled by default', class4b.new.call.value[:msg])
ensure
Solid::Result.config.addon.disable!(:continue)
class1c = Class.new do
include Solid::Result.mixin
def call
Continue("this method won't exist as the default config is disabled")
end
end
class2c = Class.new do
include Solid::Result::Expectations.mixin
def call
Continue("this method won't exist as the default config is disabled")
end
end
class3c = Class.new do
include Solid::Output.mixin
def call
Continue(msg: "this method won't exist as the default config is disabled")
end
end
class4c = Class.new do
include Solid::Output::Expectations.mixin
def call
Continue(msg: "this method won't exist as the default config is disabled")
end
end
error1c = assert_raises(NoMethodError) { class1c.new.call }
error2c = assert_raises(NoMethodError) { class2c.new.call }
error3c = assert_raises(NoMethodError) { class3c.new.call }
error4c = assert_raises(NoMethodError) { class4c.new.call }
assert_match(/undefined method.+Continue/, error1c.message)
assert_match(/undefined method.+Continue/, error2c.message)
assert_match(/undefined method.+Continue/, error3c.message)
assert_match(/undefined method.+Continue/, error4c.message)
end
test 'the overwriting of the default config' do
Solid::Result.config.addon.enable!(:continue)
class1 = Class.new do
include Solid::Result.mixin(config: { addon: { continue: false } })
def call
Continue("this method won't exist as the default config was overwritten")
end
end
class2 = Class.new do
include Solid::Result::Expectations.mixin(config: { addon: { continue: false } })
def call
Continue("this method won't exist as the default config was overwritten")
end
end
class3 = Class.new do
include Solid::Output.mixin(config: { addon: { continue: false } })
def call
Continue(msg: "this method won't exist as the default config was overwritten")
end
end
class4 = Class.new do
include Solid::Output::Expectations.mixin(config: { addon: { continue: false } })
def call
Continue(msg: "this method won't exist as the default config was overwritten")
end
end
error1 = assert_raises(NoMethodError) { class1.new.call }
error2 = assert_raises(NoMethodError) { class2.new.call }
error3 = assert_raises(NoMethodError) { class3.new.call }
error4 = assert_raises(NoMethodError) { class4.new.call }
assert_match(/undefined method.+Continue/, error1.message)
assert_match(/undefined method.+Continue/, error2.message)
assert_match(/undefined method.+Continue/, error3.message)
assert_match(/undefined method.+Continue/, error4.message)
ensure
Solid::Result.config.addon.disable!(:continue)
end
end
end
solid-result-2.0.0/test/solid/result/config/addon/given_test.rb 0000664 0000000 0000000 00000011524 14606620746 0024612 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class AddonGivenTest < Minitest::Test
test 'the side effects' do
Solid::Result.config.addon.disable!(:given)
class1a = Class.new do
include Solid::Result.mixin
def call
Given("this method won't exist as the default config is disabled")
end
end
class2a = Class.new do
include Solid::Result::Expectations.mixin
def call
Given("this method won't exist as the default config is disabled")
end
end
class3a = Class.new do
include Solid::Output.mixin
def call
Given(msg: "this method won't exist as the default config is disabled")
end
end
class4a = Class.new do
include Solid::Output::Expectations.mixin
def call
Given(msg: "this method won't exist as the default config is disabled")
end
end
error1a = assert_raises(NoMethodError) { class1a.new.call }
error2a = assert_raises(NoMethodError) { class2a.new.call }
error3a = assert_raises(NoMethodError) { class3a.new.call }
error4a = assert_raises(NoMethodError) { class4a.new.call }
assert_match(/undefined method.+Given/, error1a.message)
assert_match(/undefined method.+Given/, error2a.message)
assert_match(/undefined method.+Given/, error3a.message)
assert_match(/undefined method.+Given/, error4a.message)
Solid::Result.config.addon.enable!(:given)
class1b = Class.new do
include Solid::Result.mixin
def call
Given('this method will exist as the config is enabled by default')
end
end
class2b = Class.new do
include Solid::Result::Expectations.mixin
def call
Given('this method will exist as the config is enabled by default')
end
end
class3b = Class.new do
include Solid::Output.mixin
def call
part1 = { part1: 'this method will exist' }
part2 = { part2: 'as the config is enabled by default' }
Given(part1, part2)
.and_then { |data| Given(msg: "#{data[:part1]} #{data[:part2]}") }
end
end
class4b = Class.new do
include Solid::Output::Expectations.mixin
def call
part1 = { part1: 'this method will exist' }
part2 = { part2: 'as the config is enabled by default' }
Given(part1, part2)
.and_then { |data| Given(msg: "#{data[:part1]} #{data[:part2]}") }
end
end
result1b = class1b.new.call
result2b = class2b.new.call
result3b = class3b.new.call
result4b = class4b.new.call
assert_equal('this method will exist as the config is enabled by default', result1b.value)
assert_equal('this method will exist as the config is enabled by default', result2b.value)
assert_equal('this method will exist as the config is enabled by default', result3b.value[:msg])
assert_equal('this method will exist as the config is enabled by default', result4b.value[:msg])
assert(result1b.success?(:_given_))
assert(result2b.success?(:_given_))
assert(result3b.success?(:_given_) && result3b.value.keys == [:msg])
assert(result4b.success?(:_given_) && result4b.value.keys == [:msg])
end
test 'the overwriting of the default config' do
Solid::Result.config.addon.enable!(:given)
class1 = Class.new do
include Solid::Result.mixin(config: { addon: { given: false } })
def call
Given("this method won't exist as the default config was overwritten")
end
end
class2 = Class.new do
include Solid::Result::Expectations.mixin(config: { addon: { given: false } })
def call
Given("this method won't exist as the default config was overwritten")
end
end
class3 = Class.new do
include Solid::Output.mixin(config: { addon: { given: false } })
def call
Given(msg: "this method won't exist as the default config was overwritten")
end
end
class4 = Class.new do
include Solid::Output::Expectations.mixin(config: { addon: { given: false } })
def call
Given(msg: "this method won't exist as the default config was overwritten")
end
end
error1 = assert_raises(NoMethodError) { class1.new.call }
error2 = assert_raises(NoMethodError) { class2.new.call }
error3 = assert_raises(NoMethodError) { class3.new.call }
error4 = assert_raises(NoMethodError) { class4.new.call }
assert_match(/undefined method.+Given/, error1.message)
assert_match(/undefined method.+Given/, error2.message)
assert_match(/undefined method.+Given/, error3.message)
assert_match(/undefined method.+Given/, error4.message)
end
end
end
solid-result-2.0.0/test/solid/result/config/addon_test.rb 0000664 0000000 0000000 00000001135 14606620746 0023477 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class AddonTest < Minitest::Test
AFFECTS = [
'Solid::Result.mixin',
'Solid::Output.mixin',
'Solid::Result::Expectations.mixin',
'Solid::Output::Expectations.mixin'
].freeze
test 'the switcher' do
config = Solid::Result.config.addon
assert_instance_of(Switcher, config)
assert_equal(
{
continue: { enabled: false, affects: AFFECTS },
given: { enabled: true, affects: AFFECTS }
},
config.options
)
end
end
end
solid-result-2.0.0/test/solid/result/config/constant_alias/ 0000775 0000000 0000000 00000000000 14606620746 0024030 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/config/constant_alias/result_test.rb 0000664 0000000 0000000 00000000707 14606620746 0026736 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class ConstantAliasResultTest < Minitest::Test
test 'the side effects (Result)' do
assert_raises(NameError) { ::Result }
Solid::Result.config.constant_alias.enable!('Result')
assert_same(Solid::Result, ::Result)
ensure
Solid::Result.config.constant_alias.disable!('Result')
assert_raises(NameError) { ::Result }
end
end
end
solid-result-2.0.0/test/solid/result/config/constant_alias_test.rb 0000664 0000000 0000000 00000000620 14606620746 0025412 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class ConstantAliasTest < Minitest::Test
test 'the switcher' do
config = Solid::Result.config.constant_alias
assert_instance_of(Switcher, config)
assert_equal(
{
'Result' => { enabled: false, affects: ['Object'] }
},
config.options
)
end
end
end
solid-result-2.0.0/test/solid/result/config/feature/ 0000775 0000000 0000000 00000000000 14606620746 0022461 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/config/feature/and_then_bang_test.rb 0000664 0000000 0000000 00000004775 14606620746 0026631 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class FeatureAndThenBangTest < Minitest::Test
class AddR
include Solid::Result.mixin
def call(arg1, arg2)
Success(:ok, arg1 + arg2)
end
end
AddR1 = ->(value) { AddR.new.call(value, 1) }
module AddR2
def self.call(value)
AddR.new.call(value, 2)
end
end
module AddR3
def self.perform(value)
AddR.new.call(value, 3)
end
end
class AddC
include Solid::Output.mixin
def call(number1:, number2:)
Success(:ok, number: number1 + number2)
end
end
AddC1 = ->(number:) { AddC.new.call(number1: number, number2: 1) }
module AddC2
def self.call(number:)
AddC.new.call(number1: number, number2: 2)
end
end
module AddC3
def self.perform(number:)
AddC.new.call(number1: number, number2: 3)
end
end
test 'the side effects' do
Solid::Result.config.feature.enable!(:and_then!)
result1 =
AddR1[1]
.and_then!(AddR2)
.and_then!(AddR3, _call: :perform)
.and_then!(AddR1)
result2 =
AddC1[number: 2]
.and_then!(AddC2)
.and_then!(AddC3, _call: :perform)
.and_then!(AddC1)
assert(result1.success?(:ok) && result1.value == 8)
assert(result2.success?(:ok) && result2.value == { number: 9 })
Solid::Result.config.feature.disable!(:and_then!)
expected_error =
'You cannot use #and_then! as the feature is disabled. ' \
'Please use Solid::Result.config.feature.enable!(:and_then!) to enable it.'
assert_raises(Solid::Result::Error::CallableAndThenDisabled, expected_error) { AddR1.call(1).and_then!(AddR2) }
assert_raises(Solid::Result::Error::CallableAndThenDisabled, expected_error) { AddC1[number: 2].and_then!(AddC2) }
ensure
Solid::Result.config.feature.disable!(:and_then!)
end
test 'the default method name' do
Solid::Result.config.feature.enable!(:and_then!)
Solid::Result.config.and_then!.default_method_name_to_call = :perform
result1 = AddR1[1].and_then!(AddR3)
result2 = AddC1[number: 2].and_then!(AddC3)
assert(result1.success?(:ok) && result1.value == 5)
assert(result2.success?(:ok) && result2.value == { number: 6 })
ensure
Solid::Result.config.feature.disable!(:and_then!)
Solid::Result.config.and_then!.default_method_name_to_call = :call
end
end
end
solid-result-2.0.0/test/solid/result/config/feature/event_logs_listener_test.rb 0000664 0000000 0000000 00000013135 14606620746 0030122 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class FeatureEventLogsListenerTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Solid::Result.event_logs(name: 'Division') do
Given([arg1, arg2])
.and_then(:require_numbers)
.and_then(:check_for_zeros)
.and_then(:divide)
end
end
private
ValidNumber = ->(arg) { arg.is_a?(Numeric) && (!arg.respond_to?(:finite?) || arg.finite?) }
def require_numbers((arg1, arg2))
ValidNumber[arg1] or return Failure(:invalid_arg, 'arg1 must be a valid number')
ValidNumber[arg2] or return Failure(:invalid_arg, 'arg2 must be a valid number')
Continue([arg1, arg2])
end
def check_for_zeros(numbers)
numbers.first.zero? ? Success(:division_completed, 0) : Continue(numbers)
end
def divide((num1, num2))
Success(:division_completed, num1 / num2)
end
end
module InspectListener
extend Solid::Result::EventLogs::Listener
class << self
attr_reader :memo
def new
tap { @memo = Hash.new { |hash, key| hash[key] = [] } }
end
def on_start(scope:)
memo[:on_start] << scope
end
def around_event_logs(scope:)
memo[:around_event_logs] << scope
yield
end
def around_and_then(scope:, and_then:)
memo[:around_and_then] << { scope: scope, and_then: and_then }
yield
end
def on_record(record:)
memo[:on_record] << record
end
def on_finish(event_logs:)
memo[:on_finish] << event_logs
end
def before_interruption(exception:, event_logs:)
memo[:before_interruption] << { exception: exception, event_logs: event_logs }
end
end
end
test 'valid listener config (without event_logs interruption)' do
original_listener = Solid::Result.config.event_logs.listener
Solid::Result.config.event_logs.listener = InspectListener
result = Division.new.call(10, 2)
scope = { id: 0, name: 'Division', desc: nil }
assert_equal([scope], InspectListener.memo[:on_start])
assert_equal([scope], InspectListener.memo[:around_event_logs])
[
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :require_numbers } },
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :check_for_zeros } },
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :divide } }
].each_with_index do |and_then, index|
assert_equal(and_then, InspectListener.memo[:around_and_then][index])
end
result.event_logs[:records].each_with_index do |record, index|
assert_equal(record, InspectListener.memo[:on_record][index])
end
assert_equal(result.event_logs, InspectListener.memo[:on_finish].first)
ensure
Solid::Result.config.event_logs.listener = original_listener
end
test 'valid listener config (with event_logs interruption)' do
original_listener = Solid::Result.config.event_logs.listener
Solid::Result.config.event_logs.listener = InspectListener
assert_raises(ZeroDivisionError, 'divided by 0') { Division.new.call(10, 0) }
scope = { id: 0, name: 'Division', desc: nil }
assert_equal([scope], InspectListener.memo[:on_start])
assert_equal([scope], InspectListener.memo[:around_event_logs])
[
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :require_numbers } },
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :check_for_zeros } },
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :divide } }
].each_with_index do |and_then, index|
assert_equal(and_then, InspectListener.memo[:around_and_then][index])
end
on_record = InspectListener.memo[:on_record]
assert_equal(3, on_record.size)
assert_equal(:_given_, on_record.dig(0, :result, :type))
assert_equal(:require_numbers, on_record.dig(1, :and_then, :method_name))
assert_equal(:check_for_zeros, on_record.dig(2, :and_then, :method_name))
before_interruption = InspectListener.memo[:before_interruption].first
assert_instance_of(ZeroDivisionError, before_interruption[:exception])
assert_event_logs!(before_interruption[:event_logs], size: 3)
assert_equal(on_record, before_interruption[:event_logs][:records])
ensure
Solid::Result.config.event_logs.listener = original_listener
end
test 'invalid listener config' do
err = assert_raises(ArgumentError) { Solid::Result.config.event_logs.listener = 1 }
assert_equal('1 must be a Solid::Result::EventLogs::Listener', err.message)
end
class BrokenListener
include Solid::Result::EventLogs::Listener
def initialize
raise 'broken'
end
end
test 'broken listener' do
original_listener = Solid::Result.config.event_logs.listener
Solid::Result.config.event_logs.listener = BrokenListener
stderr1 = /Fallback to Solid::Result::EventLogs::Listener::Null because registered listener raised an exception:/
assert_output(nil, stderr1) { Division.new.call(1, 2) }
stderr2 = /raised an exception: broken \(RuntimeError\); Backtrace:.+/
assert_output(nil, stderr2) { Division.new.call(2, 2) }
ensure
Solid::Result.config.event_logs.listener = original_listener
end
end
end
solid-result-2.0.0/test/solid/result/config/feature/event_logs_trace_id_test.rb 0000664 0000000 0000000 00000001704 14606620746 0030046 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class FeatureEventLogsTraceIdTest < Minitest::Test
include SolidResultEventLogAssertions
test 'valid trace_id config' do
original_trace_id = Solid::Result.config.event_logs.trace_id
random_number = rand
Solid::Result.config.event_logs.trace_id = -> { random_number }
result = nil
Solid::Result.event_logs do
result = Solid::Result::Success(:ok, 1)
end
assert_equal(random_number, result.event_logs.dig(:metadata, :trace_id))
assert_event_logs(result, size: 1, trace_id: random_number)
ensure
Solid::Result.config.event_logs.trace_id = original_trace_id
end
test 'invalid trace_id config' do
err = assert_raises(ArgumentError) do
Solid::Result.config.event_logs.trace_id = 'invalid'
end
assert_equal('must be a lambda with arity 0', err.message)
end
end
end
solid-result-2.0.0/test/solid/result/config/feature/expectations_test.rb 0000664 0000000 0000000 00000011606 14606620746 0026557 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class FeatureExpectationsTest < Minitest::Test
test 'the side effects' do
class1a = Class.new do
include Solid::Result::Expectations.mixin(success: { ok: ::Numeric })
def call; Success(:ok, '1'); end
end
class1b = Class.new
class1b.const_set(:Result, Solid::Result::Expectations.new(success: { ok: ::Numeric }))
class1b.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, '1'); end }
class1c = Class.new do
include Solid::Output::Expectations.mixin(success: { ok: ->(v) { v[:one] == 1 } })
def call; Success(:yes, one: 1); end
end
class1d = Class.new
class1d.const_set(:Result, Solid::Output::Expectations.new(success: { ok: ->(v) { v[:one] == 1 } }))
class1d.class_eval { def call; self.class.const_get(:Result, false)::Success(:yes, one: 1); end }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1a.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1b.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { class1a::Result::Success(:yes, 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { class1b::Result::Success(:yes, 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1c::Result::Success(:ok, one: 2) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1d::Result::Success(:ok, one: 2) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { class1c.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { class1d.new.call }
Solid::Result.config.feature.disable!(:expectations)
class2a = Class.new do
include Solid::Result::Expectations.mixin(success: { ok: ::Numeric })
def call; Success(:ok, '1'); end
end
class2b = Class.new
class2b.const_set(:Result, Solid::Result::Expectations.new(success: { ok: ::Numeric }))
class2b.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, '1'); end }
class2c = Class.new do
include Solid::Output::Expectations.mixin(success: { ok: ->(v) { v[:one] == 1 } })
def call; Success(:yes, one: 1); end
end
class2d = Class.new
class2d.const_set(:Result, Solid::Output::Expectations.new(success: { ok: ->(v) { v[:one] == 1 } }))
class2d.class_eval { def call; self.class.const_get(:Result, false)::Success(:yes, one: 1); end }
assert(class2a.new.call.then { _1.success?(:ok) && _1.value == '1' })
assert(class2b.new.call.then { _1.success?(:ok) && _1.value == '1' })
assert(class2c.new.call.then { _1.success?(:yes) && _1.value == { one: 1 } })
assert(class2d.new.call.then { _1.success?(:yes) && _1.value == { one: 1 } })
assert(class2a::Result::Success(:yes, 1).then { _1.success?(:yes) && _1.value == 1 })
assert(class2b::Result::Success(:yes, 1).then { _1.success?(:yes) && _1.value == 1 })
assert(class2c::Result::Success(:ok, one: 2).then { _1.success?(:ok) && _1.value == { one: 2 } })
assert(class2d::Result::Success(:ok, one: 2).then { _1.success?(:ok) && _1.value == { one: 2 } })
ensure
Solid::Result.config.feature.enable!(:expectations)
class3a = Class.new do
include Solid::Result::Expectations.mixin(success: { ok: ::Numeric })
def call; Success(:ok, '1'); end
end
class3b = Class.new
class3b.const_set(:Result, Solid::Result::Expectations.new(success: { ok: ::Numeric }))
class3b.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, '1'); end }
class3c = Class.new do
include Solid::Output::Expectations.mixin(success: { ok: ->(v) { v[:one] == 1 } })
def call; Success(:yes, one: 1); end
end
class3d = Class.new
class3d.const_set(:Result, Solid::Output::Expectations.new(success: { ok: ->(v) { v[:one] == 1 } }))
class3d.class_eval { def call; self.class.const_get(:Result, false)::Success(:yes, one: 1); end }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3a.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3b.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { class3a::Result::Success(:yes, 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { class3b::Result::Success(:yes, 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3c::Result::Success(:ok, one: 2) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3d::Result::Success(:ok, one: 2) }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { class3c.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedType) { class3d.new.call }
end
end
end
solid-result-2.0.0/test/solid/result/config/feature_test.rb 0000664 0000000 0000000 00000001450 14606620746 0024045 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class FeatureInstanceTest < Minitest::Test
test 'the switcher' do
config = Solid::Result.config.feature
assert_instance_of(Switcher, config)
assert_equal(
{
expectations: {
enabled: true,
affects: ['Solid::Result::Expectations', 'Solid::Output::Expectations']
},
event_logs: { enabled: true, affects: %w[
Solid::Result Solid::Output Solid::Result::Expectations Solid::Output::Expectations
] },
and_then!: { enabled: false, affects: %w[
Solid::Result Solid::Output Solid::Result::Expectations Solid::Output::Expectations
] }
},
config.options
)
end
end
end
solid-result-2.0.0/test/solid/result/config/pattern_matching/ 0000775 0000000 0000000 00000000000 14606620746 0024355 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/config/pattern_matching/nil_as_valid_value_checking_test.rb 0000664 0000000 0000000 00000017153 14606620746 0033423 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class PatternMatchingNilAsAValidValueCheckingTest < Minitest::Test
test 'the side effects' do
is_numeric = ->(v) do
case v
in Numeric then true
end
nil
end
is_hash_numeric = ->(v) do
case v
in { number: Numeric } then true
end
nil
end
class1a = Class.new do
include Solid::Result::Expectations.mixin(success: { ok: is_numeric })
def call; Success(:ok, 1); end
end
class1b = Class.new
class1b.const_set(:Result, Solid::Result::Expectations.new(success: { ok: is_numeric }))
class1b.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, 1); end }
class1c = Class.new do
include Solid::Output::Expectations.mixin(success: { ok: is_hash_numeric })
def call; Success(:ok, number: 1); end
end
class1d = Class.new
class1d.const_set(:Result, Solid::Output::Expectations.new(success: { ok: is_hash_numeric }))
class1d.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, number: 1); end }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1a.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1b.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1c.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1d.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1a::Result::Success(:ok, 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1b::Result::Success(:ok, 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1c::Result::Success(:ok, number: 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1d::Result::Success(:ok, number: 1) }
Solid::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
class2a = Class.new do
include Solid::Result::Expectations.mixin(success: { ok: is_numeric })
def call; Success(:ok, 1); end
end
class2b = Class.new
class2b.const_set(:Result, Solid::Result::Expectations.new(success: { ok: is_numeric }))
class2b.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, 1); end }
class2c = Class.new do
include Solid::Output::Expectations.mixin(success: { ok: is_hash_numeric })
def call; Success(:ok, number: 1); end
end
class2d = Class.new
class2d.const_set(:Result, Solid::Output::Expectations.new(success: { ok: is_hash_numeric }))
class2d.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, number: 1); end }
assert(class2a.new.call.then { _1.success?(:ok) && _1.value == 1 })
assert(class2b.new.call.then { _1.success?(:ok) && _1.value == 1 })
assert(class2c.new.call.then { _1.success?(:ok) && _1.value == { number: 1 } })
assert(class2d.new.call.then { _1.success?(:ok) && _1.value == { number: 1 } })
assert(class2a::Result::Success(:ok, 1).then { _1.success?(:ok) && _1.value == 1 })
assert(class2b::Result::Success(:ok, 1).then { _1.success?(:ok) && _1.value == 1 })
assert(class2c::Result::Success(:ok, number: 1).then { _1.success?(:ok) && _1.value == { number: 1 } })
assert(class2d::Result::Success(:ok, number: 1).then { _1.success?(:ok) && _1.value == { number: 1 } })
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class2a::Result::Success(:ok, '1') }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class2b::Result::Success(:ok, '1') }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class2c::Result::Success(:ok, number: '1') }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class2d::Result::Success(:ok, number: '1') }
ensure
Solid::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
class3a = Class.new do
include Solid::Result::Expectations.mixin(success: { ok: is_numeric })
def call; Success(:ok, 1); end
end
class3b = Class.new
class3b.const_set(:Result, Solid::Result::Expectations.new(success: { ok: is_numeric }))
class3b.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, 1); end }
class3c = Class.new do
include Solid::Output::Expectations.mixin(success: { ok: is_hash_numeric })
def call; Success(:ok, number: 1); end
end
class3d = Class.new
class3d.const_set(:Result, Solid::Output::Expectations.new(success: { ok: is_hash_numeric }))
class3d.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, number: 1); end }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3a.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3b.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3c.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3d.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3a::Result::Success(:ok, 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3b::Result::Success(:ok, 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3c::Result::Success(:ok, number: 1) }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3d::Result::Success(:ok, number: 1) }
end
test 'the overwriting of the default config' do
Solid::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
is_numeric = ->(v) do
case v
in Numeric then true
end
nil
end
is_hash_numeric = ->(v) do
case v
in { number: Numeric } then true
end
nil
end
class1 = Class.new do
include Solid::Result::Expectations.mixin(
config: { pattern_matching: { nil_as_valid_value_checking: false } },
success: { ok: is_numeric }
)
def call; Success(:ok, 1); end
end
class2 = Class.new
class2.const_set(
:Result,
Solid::Result::Expectations.new(
config: { pattern_matching: { nil_as_valid_value_checking: false } },
success: { ok: is_numeric }
)
)
class2.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, 1); end }
class3 = Class.new do
include Solid::Output::Expectations.mixin(
config: { pattern_matching: { nil_as_valid_value_checking: false } },
success: { ok: is_hash_numeric }
)
def call; Success(:ok, number: 1); end
end
class4 = Class.new
class4.const_set(
:Result,
Solid::Output::Expectations.new(
config: { pattern_matching: { nil_as_valid_value_checking: false } },
success: { ok: is_hash_numeric }
)
)
class4.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, number: 1); end }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class1.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class2.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class3.new.call }
assert_raises(Solid::Result::Contract::Error::UnexpectedValue) { class4.new.call }
ensure
Solid::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
end
end
end
solid-result-2.0.0/test/solid/result/config/pattern_matching_test.rb 0000664 0000000 0000000 00000001045 14606620746 0025741 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class PatternMatchingTest < Minitest::Test
test 'the switcher' do
config = Solid::Result.config.pattern_matching
assert_instance_of(Switcher, config)
assert_equal(
{
nil_as_valid_value_checking: {
enabled: false,
affects: [
'Solid::Result::Expectations',
'Solid::Output::Expectations'
]
}
},
config.options
)
end
end
end
solid-result-2.0.0/test/solid/result/config/switcher_test.rb 0000664 0000000 0000000 00000010461 14606620746 0024244 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class SwitcherTest < Minitest::Test
test '#inspect' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
assert_equal(
'#true, :bar=>false}>',
switcher.inspect
)
end
test '#freeze' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
switcher.freeze
assert_raises(FrozenError) { switcher.enable!(:foo) }
assert_raises(FrozenError) { switcher.disable!(:foo) }
assert switcher.enabled?(:foo)
refute switcher.enabled?(:bar)
assert_equal({ foo: true, bar: false }, switcher.to_h)
assert_equal(
{
foo: { enabled: true, affects: ['foo'] },
bar: { enabled: false, affects: ['bar'] }
},
switcher.options
)
end
test '#to_h' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
assert_equal(
{ foo: true, bar: false },
switcher.to_h
)
end
test '#options' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
assert_equal(
{
foo: { enabled: true, affects: ['foo'] },
bar: { enabled: false, affects: ['bar'] }
},
switcher.options
)
end
test '#enabled?' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
assert switcher.enabled?(:foo)
refute switcher.enabled?(:bar)
end
test '#enable! with valid arguments' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
switcher.enable!(:bar)
assert switcher.enabled?(:bar)
assert_equal({ bar: { enabled: true, affects: ['bar'] } }, switcher.enable!(:bar))
end
test '#enable! without arguments' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
error = assert_raises(ArgumentError) { switcher.enable! }
assert_equal('One or more options required. Available options: :foo, :bar', error.message)
end
test '#enable! with invalid arguments' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
error = assert_raises(ArgumentError) { switcher.enable!(:baz) }
assert_equal('Invalid option: :baz. Available options: :foo, :bar', error.message)
end
test '#disable! with valid arguments' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
switcher.disable!(:foo)
refute switcher.enabled?(:foo)
assert_equal({ foo: { enabled: false, affects: ['foo'] } }, switcher.disable!(:foo))
end
test '#disable! without arguments' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
error = assert_raises(ArgumentError) { switcher.disable! }
assert_equal('One or more options required. Available options: :foo, :bar', error.message)
end
test '#disable! with invalid arguments' do
switcher = Switcher.new(
options: {
foo: { default: true, affects: ['foo'] },
bar: { default: false, affects: ['bar'] }
}
)
error = assert_raises(ArgumentError) { switcher.disable!(:baz) }
assert_equal('Invalid option: :baz. Available options: :foo, :bar', error.message)
end
end
end
solid-result-2.0.0/test/solid/result/config_test.rb 0000664 0000000 0000000 00000005073 14606620746 0022417 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Config
class Test < Minitest::Test
test '.instance' do
assert Solid::Result::Config.instance.is_a?(Solid::Result::Config)
assert_same(Solid::Result::Config.instance, Solid::Result.config)
end
test '#addon' do
assert_respond_to(Solid::Result.config, :addon)
end
test '#feature' do
assert_respond_to(Solid::Result.config, :feature)
end
test '#constant_alias' do
assert_respond_to(Solid::Result.config, :constant_alias)
end
test '#pattern_matching' do
assert_respond_to(Solid::Result.config, :pattern_matching)
end
test '#options' do
assert_instance_of(Hash, Solid::Result.config.options)
assert_equal(
%i[
addon
constant_alias
feature
pattern_matching
],
Solid::Result.config.options.keys.sort
)
Solid::Result.config.options.each_value do |switcher|
assert_instance_of(Switcher, switcher)
end
end
test '#to_h' do
config_values = Solid::Result.config.to_h
assert_equal({ continue: false, given: true }, config_values[:addon])
assert_equal({ expectations: true, event_logs: true, and_then!: false }, config_values[:feature])
assert_equal({ nil_as_valid_value_checking: false }, config_values[:pattern_matching])
assert_equal({ 'Result' => false }, config_values[:constant_alias])
Solid::Result.config.options.each do |key, switcher|
assert_equal(switcher.to_h, config_values[key])
end
end
test '#inspect' do
assert_equal(
'#:call}>',
Solid::Result.config.inspect
)
end
test '#freeze' do
event_logs_config_instance = Solid::Result::EventLogs::Config.send(:new)
Solid::Result::EventLogs::Config.expects(:instance).returns(event_logs_config_instance)
instance = Solid::Result::Config.send(:new)
assert_instance_of(Solid::Result::Config, instance)
refute_same(Solid::Result::Config.instance, instance)
instance.freeze
assert_predicate(instance, :frozen?)
assert_predicate(instance.addon, :frozen?)
assert_predicate(instance.feature, :frozen?)
assert_predicate(instance.constant_alias, :frozen?)
assert_predicate(instance.pattern_matching, :frozen?)
assert_predicate(event_logs_config_instance, :frozen?)
end
end
end
solid-result-2.0.0/test/solid/result/configuration_test.rb 0000664 0000000 0000000 00000002702 14606620746 0024015 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class ConfigurationTest < Minitest::Test
test '.configuration' do
config_instance = Config.send(:new)
event_logs_config_instance = EventLogs::Config.send(:new)
Solid::Result.expects(:config).twice.returns(config_instance)
EventLogs::Config.expects(:instance).returns(event_logs_config_instance)
refute_predicate(config_instance, :frozen?)
refute(config_instance.addon.enabled?(:continue))
Solid::Result.configuration do |config|
assert_same(config_instance, config)
config.addon.enable!(:continue)
refute_predicate(config_instance, :frozen?)
end
assert(config_instance.addon.enabled?(:continue))
assert_predicate(config_instance, :frozen?)
end
test 'configuration freezing' do
String(ENV.fetch('TEST_CONFIG_FREEZING', nil)).match?(/true/i) or return
refute(Solid::Result.config.addon.enabled?(:continue))
Solid::Result.configuration do |config|
assert_same(Solid::Result.config, config)
config.addon.enable!(:continue)
refute_predicate(Solid::Result.config, :frozen?)
end
assert(Solid::Result.config.addon.enabled?(:continue))
assert_predicate(Solid::Result.config, :frozen?)
assert_predicate(Solid::Result.config.and_then!, :frozen?)
assert_predicate(Solid::Result.config.event_logs, :frozen?)
end
end
end
solid-result-2.0.0/test/solid/result/contract/ 0000775 0000000 0000000 00000000000 14606620746 0021376 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/contract/for_types_and_values_test.rb 0000664 0000000 0000000 00000000464 14606620746 0027201 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class Contract::ForTypesAndValuesTest < Minitest::Test
test '#type?' do
contract = Contract::ForTypesAndValues.new({ ok: Object }, nil)
assert contract.type?(:ok)
refute contract.type?(:yes)
end
end
end
solid-result-2.0.0/test/solid/result/contract/interface_test.rb 0000664 0000000 0000000 00000001570 14606620746 0024725 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class Contract::InterfaceTest < Minitest::Test
test '#allowed_types' do
object = Object.new.extend(Contract::Interface)
assert_raises(Error::NotImplemented) do
object.allowed_types
end
end
test '#type?' do
object = Object.new.extend(Contract::Interface)
assert_raises(Error::NotImplemented) do
object.type?(:ok)
end
end
test '#type!' do
object = Object.new.extend(Contract::Interface)
assert_raises(Error::NotImplemented) do
object.type!(:ok)
end
end
test '#type_and_value!' do
data = Solid::Result::Success(:ok, 'value').data
object = Object.new.extend(Contract::Interface)
assert_raises(Error::NotImplemented) do
object.type_and_value!(data)
end
end
end
end
solid-result-2.0.0/test/solid/result/contract/nil_as_valid_value_checking_test.rb 0000664 0000000 0000000 00000003101 14606620746 0030430 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class Contract::NiltAsValidValueCheckingTest < Minitest::Test
test 'Solid::Result::Expectations' do
contract = {
ok: ->(value) {
case value
in Numeric then nil
end
}
}
_Result1 = Solid::Result::Expectations.new(success: contract)
assert_raises(Contract::Error::UnexpectedValue) do
_Result1::Success(:ok, 1)
end
Solid::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
_Result2 = Solid::Result::Expectations.new(success: contract)
result = _Result2::Success(:ok, 1)
assert result.success?(:ok)
assert_equal(1, result.value)
ensure
Solid::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
end
test 'Solid::Output::Expectations' do
contract = {
ok: ->(value) {
case value
in { number: Numeric } then nil
end
}
}
_Result1 = Solid::Output::Expectations.new(success: contract)
assert_raises(Contract::Error::UnexpectedValue) do
_Result1::Success(:ok, number: 1)
end
Solid::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
_Result2 = Solid::Output::Expectations.new(success: contract)
result = _Result2::Success(:ok, number: 1)
assert result.success?(:ok)
assert_equal({ number: 1 }, result.value)
ensure
Solid::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
end
end
end
solid-result-2.0.0/test/solid/result/data_test.rb 0000664 0000000 0000000 00000004263 14606620746 0022063 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class DataTest < Minitest::Test
test '#kind' do
success = Success.new(type: :ok, value: 1)
failure = Failure.new(type: :err, value: 0)
assert_equal :success, success.data.kind
assert_equal :failure, failure.data.kind
end
test '#type' do
success = Success.new(type: :ok, value: 1)
failure = Failure.new(type: :err, value: 0)
assert_equal :ok, success.data.type
assert_equal :err, failure.data.type
end
test '#value' do
success = Success.new(type: :ok, value: 1)
failure = Failure.new(type: :err, value: 0)
assert_equal 1, success.data.value
assert_equal 0, failure.data.value
end
test '#to_a' do
success = Success.new(type: :ok, value: 1)
failure = Failure.new(type: :err, value: 0)
assert_equal([:success, :ok, 1], success.data.to_a)
assert_equal([:failure, :err, 0], failure.data.to_a)
end
test '#to_ary' do
success = Success.new(type: :ok, value: 1)
failure = Failure.new(type: :err, value: 0)
assert_equal([:success, :ok, 1], success.data.to_ary)
assert_equal([:failure, :err, 0], failure.data.to_ary)
end
test '#to_h' do
success = Success.new(type: :ok, value: 1)
failure = Failure.new(type: :err, value: 0)
assert_equal({ kind: :success, type: :ok, value: 1 }, success.data.to_h)
assert_equal({ kind: :failure, type: :err, value: 0 }, failure.data.to_h)
end
test '#to_hash' do
success = Success.new(type: :ok, value: 1)
failure = Failure.new(type: :err, value: 0)
assert_equal({ kind: :success, type: :ok, value: 1 }, success.data.to_hash)
assert_equal({ kind: :failure, type: :err, value: 0 }, failure.data.to_hash)
end
test '#inspect' do
success = Success.new(type: :ok, value: 1)
failure = Failure.new(type: :err, value: 0)
assert_equal(
'#',
success.data.inspect
)
assert_equal(
'#',
failure.data.inspect
)
end
end
end
solid-result-2.0.0/test/solid/result/error_test.rb 0000664 0000000 0000000 00000004475 14606620746 0022310 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ErrorTest < Minitest::Test
test '::Error' do
assert Solid::Result::Error < StandardError
end
test '::Error.build' do
hash = [{}, { a: 1 }, { b: 2 }].sample
error = Solid::Result::Error.build(**hash)
assert_instance_of Solid::Result::Error, error
assert_equal Solid::Result::Error.new.message, error.message
end
test '::Error::NotImplemented' do
assert Solid::Result::Error::NotImplemented < Solid::Result::Error
end
test '::Error::MissingTypeArgument' do
assert Solid::Result::Error::MissingTypeArgument < Solid::Result::Error
assert_equal(
'A type (argument) is required to invoke the #on/#on_type method',
Solid::Result::Error::MissingTypeArgument.new.message
)
end
test '::Error::UnexpectedOutcome.build' do
assert Solid::Result::Error::UnexpectedOutcome < Solid::Result::Error
error_input = { outcome: { a: 1 }, origin: :block }
assert_equal(
'Unexpected outcome: {:a=>1}. The block must return this object wrapped by ' \
'Solid::Result::Success or Solid::Result::Failure',
Solid::Result::Error::UnexpectedOutcome.build(**error_input).message
)
end
test '::Error::InvalidResultSource.build' do
assert Solid::Result::Error::InvalidResultSource < Solid::Result::Error
given_result = Solid::Result::Success.new(type: :number, value: 3, source: 1)
error_input = { given_result: given_result, expected_source: 2 }
assert_equal(
"You cannot call #and_then and return a result that does not belong to the same source!\n" \
"Expected source: 2\n" \
"Given source: 1\n" \
'Given result: #',
Solid::Result::Error::InvalidResultSource.build(**error_input).message
)
end
test '::Error::InvalidSourceMethodArity.build' do
assert Solid::Result::Error::InvalidSourceMethodArity < Solid::Result::Error
source = Object.new
def source.do_something(_arg1, _arg2, _arg3); end
method = source.method(:do_something)
error_input = { source: source, method: method, max_arity: 2 }
assert_equal(
'Object#do_something has unsupported arity (3). Expected 0..2',
Solid::Result::Error::InvalidSourceMethodArity.build(**error_input).message
)
end
end
solid-result-2.0.0/test/solid/result/event_logs/ 0000775 0000000 0000000 00000000000 14606620746 0021726 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/disabled/ 0000775 0000000 0000000 00000000000 14606620746 0023475 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/disabled/with_source/ 0000775 0000000 0000000 00000000000 14606620746 0026030 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/disabled/with_source/flat_test.rb 0000664 0000000 0000000 00000004703 14606620746 0030346 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsDisabledWithSourceFlatTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
class Division
include Solid::Result.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, 'num2 must be numeric')
Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Success(:ok, numbers)
end
def divide((num1, num2))
Success(:ok, num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.new.call('4', 2)
result2 = Division.new.call(4, '2')
result3 = Division.new.call(4, 0)
result4 = Division.new.call(4, 2)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.new.call('4', 2) }
t2 = Thread.new { Division.new.call(4, '2') }
t3 = Thread.new { Division.new.call(4, 0) }
t4 = Thread.new { Division.new.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
result2 = Division.new.call(4, 2)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.new.call(4, 2)
result2 = Division.new.call(4, 0)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/disabled/with_source/nested_test.rb 0000664 0000000 0000000 00000006131 14606620746 0030677 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsDisabledWithSourceNestedTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
module Division
extend self, Solid::Result.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, 'num2 must be numeric')
Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Success(:ok, numbers)
end
def divide((num1, num2))
Success(:ok, num1 / num2)
end
end
class SumDivisionsByTwo
include Solid::Result.mixin
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Failure(:errors, divisions.select(&:failure?).map(&:value))
else
Success(:sum, divisions.sum(&:value))
end
end
end
private
def divide_by_two(num)
Division.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.new.call('30', '20', '10')
result2 = SumDivisionsByTwo.new.call(30, '20', '10')
result3 = SumDivisionsByTwo.new.call(30, 20, '10')
result4 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.new.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.new.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.new.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.new.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
result2 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
result2 = SumDivisionsByTwo.new.call(30, 20, '10')
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/disabled/with_source/recursion_test.rb 0000664 0000000 0000000 00000002537 14606620746 0031434 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsDisabledWithSourceRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
class Fibonacci
include Solid::Result.mixin
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |number|
fibonacci = number <= 1 ? number : call(number - 1).value + call(number - 2).value
Success(:fibonacci, fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Failure(:invalid_input, 'input must be numeric')
input.negative? and return Failure(:invalid_number, 'number cannot be negative')
Success(:positive_number, input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.new.call('1')
failure2 = Fibonacci.new.call(-1)
fibonacci0 = Fibonacci.new.call(0)
fibonacci1 = Fibonacci.new.call(1)
fibonacci2 = Fibonacci.new.call(2)
assert_empty_event_logs(failure1)
assert_empty_event_logs(failure2)
assert_empty_event_logs(fibonacci0)
assert_empty_event_logs(fibonacci1)
assert_empty_event_logs(fibonacci2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/disabled/without_source/ 0000775 0000000 0000000 00000000000 14606620746 0026560 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/disabled/without_source/flat_test.rb 0000664 0000000 0000000 00000005013 14606620746 0031071 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsDisabledWithoutSourceFlatTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
module Division
extend self
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num2 must be numeric')
Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Solid::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
Solid::Result::Success(:ok, num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.call('4', 2)
result2 = Division.call(4, '2')
result3 = Division.call(4, 0)
result4 = Division.call(4, 2)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.call('4', 2) }
t2 = Thread.new { Division.call(4, '2') }
t3 = Thread.new { Division.call(4, 0) }
t4 = Thread.new { Division.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
result2 = Division.call(4, 2)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.call(4, 2)
result2 = Division.call(4, 0)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/disabled/without_source/nested_test.rb 0000664 0000000 0000000 00000006215 14606620746 0031432 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsDisabledWithoutSourceNestedTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
class Division
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num2 must be numeric')
Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
Solid::Result::Success(:ok, num1 / num2)
end
end
module SumDivisionsByTwo
extend self
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Solid::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
else
Solid::Result::Success(:sum, divisions.sum(&:value))
end
end
end
private
def divide_by_two(num)
Division.new.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.call('30', '20', '10')
result2 = SumDivisionsByTwo.call(30, '20', '10')
result3 = SumDivisionsByTwo.call(30, 20, '10')
result4 = SumDivisionsByTwo.call(30, 20, 10)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
assert_empty_event_logs(result3)
assert_empty_event_logs(result4)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
result2 = SumDivisionsByTwo.call(30, 20, 10)
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
result2 = SumDivisionsByTwo.call(30, 20, '10')
assert_empty_event_logs(result1)
assert_empty_event_logs(result2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/disabled/without_source/recursion_test.rb 0000664 0000000 0000000 00000002573 14606620746 0032164 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsDisabledWithoutSourceRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
def setup
Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
Solid::Result.config.feature.enable!(:event_logs)
end
module Fibonacci
extend self
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |number|
fibonacci = number <= 1 ? number : call(number - 1).value + call(number - 2).value
Solid::Result::Success(:fibonacci, fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Solid::Result::Failure(:invalid_input, 'input must be numeric')
input.negative? and return Solid::Result::Failure(:invalid_number, 'number cannot be negative')
Solid::Result::Success(:positive_number, input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.call('1')
failure2 = Fibonacci.call(-1)
fibonacci0 = Fibonacci.call(0)
fibonacci1 = Fibonacci.call(1)
fibonacci2 = Fibonacci.call(2)
assert_empty_event_logs(failure1)
assert_empty_event_logs(failure2)
assert_empty_event_logs(fibonacci0)
assert_empty_event_logs(fibonacci1)
assert_empty_event_logs(fibonacci2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/duration_test.rb 0000664 0000000 0000000 00000001213 14606620746 0025134 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsDurationTest < Minitest::Test
Sleep = -> { sleep(0.1).then { Solid::Result::Success(:ok) } }
test '#duration' do
return unless ENV['Solid_RESULT_TEST_EVENT_LOGS_DURATION']
result = Solid::Result.event_logs do
Sleep
.call
.and_then { Sleep.call }
.and_then { Sleep.call }
end
assert_equal(1, result.event_logs[:version])
assert_equal(3, result.event_logs[:records].size)
assert(result.event_logs[:metadata][:duration] > 299)
assert_equal([0, []], result.event_logs[:metadata][:ids][:tree])
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/ 0000775 0000000 0000000 00000000000 14606620746 0023320 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/enabled/not_been_started_test.rb 0000664 0000000 0000000 00000000602 14606620746 0030221 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsNotBeenStartedTest < Minitest::Test
include SolidResultEventLogAssertions
test 'event_logs is empty by default' do
success = Solid::Result::Success(:ok, 1)
failure = Solid::Result::Failure(:err, 0)
assert_event_logs(success, size: 0)
assert_event_logs(failure, size: 0)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/ 0000775 0000000 0000000 00000000000 14606620746 0025653 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/instance/ 0000775 0000000 0000000 00000000000 14606620746 0027457 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/instance/flat_test.rb 0000664 0000000 0000000 00000015600 14606620746 0031773 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithSourceInstanceFlatTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Solid::Result.event_logs(name: 'Division', desc: 'divide two numbers') do
require_numbers(arg1, arg2)
.and_then(:check_for_zeros)
.and_then(:divide)
end
end
private
ValidNumber = ->(arg) { arg.is_a?(Numeric) && (!arg.respond_to?(:finite?) || arg.finite?) }
def require_numbers(arg1, arg2)
ValidNumber[arg1] or return Failure(:invalid_arg, 'arg1 must be a valid number')
ValidNumber[arg2] or return Failure(:invalid_arg, 'arg2 must be a valid number')
Continue([arg1, arg2])
end
def check_for_zeros(numbers)
num1, num2 = numbers
return Failure(:division_by_zero, 'num2 cannot be zero') if num2.zero?
num1.zero? ? Success(:division_completed, 0) : Continue(numbers)
end
def divide((num1, num2))
Success(:division_completed, num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.new.call('4', 2)
result2 = Division.new.call(4, '2')
result3 = Division.new.call(4, 0)
result4 = Division.new.call(0, 2)
result5 = Division.new.call(4, 2)
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 2)
assert_event_logs(result5, size: 3)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.new.call('4', 2) }
t2 = Thread.new { Division.new.call(4, '2') }
t3 = Thread.new { Division.new.call(4, 0) }
t4 = Thread.new { Division.new.call(0, 2) }
t5 = Thread.new { Division.new.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
result5 = t5.value
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 2)
assert_event_logs(result5, size: 3)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
result2 = Division.new.call(4, 2)
assert_event_logs(result1, size: 2)
assert_event_logs(result2, size: 3)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.new.call(4, 2)
result2 = Division.new.call(0, 2)
assert_event_logs(result1, size: 3)
assert_event_logs(result2, size: 2)
end
test 'the tracking records' do
division1 = Division.new
result1 = division1.call('4', 2)
{
result: { kind: :failure, type: :invalid_arg, value: 'arg1 must be a valid number' },
and_then: ->(value) { value.is_a?(::Hash) && value.empty? }
}.then { |spec| assert_division_event_log(result1, 0, spec) }
# ---
division2 = Division.new
result2 = division2.call(4, '2')
{
result: { kind: :failure, type: :invalid_arg, value: 'arg2 must be a valid number' },
and_then: ->(value) { value.is_a?(::Hash) && value.empty? }
}.then { |spec| assert_division_event_log(result2, 0, spec) }
# ---
division3 = Division.new
result3 = division3.call(4, 0)
{
result: { kind: :success, type: :_continue_, value: [4, 0] },
and_then: ->(value) { value.is_a?(::Hash) && value.empty? }
}.then { |spec| assert_division_event_log(result3, 0, spec) }
{
result: { kind: :failure, type: :division_by_zero, value: 'num2 cannot be zero', source: division3 },
and_then: { type: :method, arg: nil, method_name: :check_for_zeros }
}.then { |spec| assert_division_event_log(result3, 1, spec) }
# ---
division4 = Division.new
result4 = division4.call(0, 2)
{
result: { kind: :success, type: :_continue_, value: [0, 2] },
and_then: ->(value) { value.is_a?(::Hash) && value.empty? }
}.then { |spec| assert_division_event_log(result4, 0, spec) }
{
result: { kind: :success, type: :division_completed, value: 0, source: division4 },
and_then: { type: :method, arg: nil, method_name: :check_for_zeros }
}.then { |spec| assert_division_event_log(result4, 1, spec) }
# ---
division5 = Division.new
result5 = division5.call(4, 2)
{
result: { kind: :success, type: :_continue_, value: [4, 2] },
and_then: ->(value) { value.is_a?(::Hash) && value.empty? }
}.then { |spec| assert_division_event_log(result5, 0, spec) }
{
result: { kind: :success, type: :_continue_, value: [4, 2], source: division5 },
and_then: { type: :method, arg: nil, method_name: :check_for_zeros }
}.then { |spec| assert_division_event_log(result5, 1, spec) }
{
result: { kind: :success, type: :division_completed, value: 2, source: division5 },
and_then: { type: :method, arg: nil, method_name: :divide }
}.then { |spec| assert_division_event_log(result5, 2, spec) }
# ---
assert_equal(1, result1.event_logs[:records].map { [_1.dig(:root, :id), _1.dig(:current, :id)] }.flatten.uniq.size)
assert_equal(1, result2.event_logs[:records].map { [_1.dig(:root, :id), _1.dig(:current, :id)] }.flatten.uniq.size)
assert_equal(1, result3.event_logs[:records].map { [_1.dig(:root, :id), _1.dig(:current, :id)] }.flatten.uniq.size)
assert_equal(1, result4.event_logs[:records].map { [_1.dig(:root, :id), _1.dig(:current, :id)] }.flatten.uniq.size)
assert_equal(1, result5.event_logs[:records].map { [_1.dig(:root, :id), _1.dig(:current, :id)] }.flatten.uniq.size)
assert_equal(
[0],
[result1, result2, result3, result4, result5]
.map { |result| result.event_logs[:records].map { _1.dig(:root, :id) }.uniq }.uniq.flatten
)
assert_equal(1, result1.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
assert_equal(1, result2.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
assert_equal(2, result3.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
assert_equal(2, result4.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
assert_equal(3, result5.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
end
def assert_division_event_log(result, index, options)
scope = {
root: { id: Integer, name: 'Division', desc: 'divide two numbers' },
parent: { id: Integer, name: 'Division', desc: 'divide two numbers' },
current: { id: Integer, name: 'Division', desc: 'divide two numbers' }
}
assert_event_log_record(result, index, scope.merge(options))
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/instance/nested_test.rb 0000664 0000000 0000000 00000022003 14606620746 0032322 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithSourceInstanceNestedTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
include Solid::Result.mixin
def call(num1, num2)
Solid::Result.event_logs(name: 'Division') do
validate_numbers(num1, num2)
.and_then(:divide, 'useless_arg')
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, 'num2 must be numeric')
Success(:ok, [num1, num2])
end
DetectZero = ->(number) do
Solid::Result.event_logs(name: 'DetectZero') do
number.zero? ? Solid::Result::Success(:is_zero) : Solid::Result::Failure(:not_zero)
end
end
CheckForZeros = ->((num1, num2)) do
Solid::Result.event_logs(name: 'CheckForZeros') do
DetectZero[num2].handle do |on|
on.success { Solid::Result::Success(:num2_is_zero) }
on.failure { num1.zero? ? Solid::Result::Success(:num1_is_zero) : Solid::Result::Failure(:no_zeros) }
end
end
end
def divide(numbers)
CheckForZeros[numbers].handle do |on|
on.success(:num2_is_zero) { Failure(:division_by_zero, 'num2 cannot be zero') }
on.success(:num1_is_zero) { Success(:division_completed, 0) }
on.failure { Success(:division_completed, numbers.first / numbers.last) }
end
end
end
class SumDivisionsByTwo
include Solid::Result.mixin
def call(*numbers)
Solid::Result.event_logs(name: 'SumDivisionsByTwo') do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Failure(:errors, divisions.select(&:failure?).map(&:value))
else
Success(:sum, divisions.sum(&:value))
end
end
end
private
def divide_by_two(num)
Division.new.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.new.call('30', '20', '10')
result2 = SumDivisionsByTwo.new.call(30, '20', '10')
result3 = SumDivisionsByTwo.new.call(30, 20, '10')
result4 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 7)
assert_event_logs(result3, size: 10)
assert_event_logs(result4, size: 13)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.new.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.new.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.new.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.new.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 7)
assert_event_logs(result3, size: 10)
assert_event_logs(result4, size: 13)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
result2 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_event_logs(result1, size: 10)
assert_event_logs(result2, size: 13)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
result2 = SumDivisionsByTwo.new.call(30, 20, '10')
assert_event_logs(result1, size: 13)
assert_event_logs(result2, size: 10)
end
test 'the tracking records (one level of nesting)' do
result = SumDivisionsByTwo.new.call('30', '20', '10')
last_event_log = result.event_logs[:records].last
assert_equal(last_event_log.dig(:current, :id), last_event_log.dig(:root, :id))
root = last_event_log.fetch(:current)
assert_hash_schema!({ id: Integer, name: 'SumDivisionsByTwo', desc: nil }, root)
{
root: root,
parent: root,
current: { id: Integer, name: 'Division', desc: nil },
result: { kind: :failure, type: :invalid_arg, value: 'num1 must be numeric', source: Division }
}.then { |spec| assert_event_log_record(result, 0, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: 'Division', desc: nil },
result: { kind: :failure, type: :invalid_arg, value: 'num1 must be numeric', source: Division }
}.then { |spec| assert_event_log_record(result, 1, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: 'Division', desc: nil },
result: { kind: :failure, type: :invalid_arg, value: 'num1 must be numeric', source: Division }
}.then { |spec| assert_event_log_record(result, 2, spec) }
{
root: root,
parent: root,
current: root,
result: { kind: :failure, type: :errors, value: ['num1 must be numeric'] * 3 }
}.then { |spec| assert_event_log_record(result, 3, spec) }
# ---
assert_equal(4, result.event_logs[:records].map { _1.dig(:current, :id) }.uniq.size)
assert_equal(4, result.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
end
test 'the tracking records (multiple level of nesting)' do
result = SumDivisionsByTwo.new.call('30', 20, 0)
last_event_log = result.event_logs[:records].last
assert_equal(last_event_log.dig(:current, :id), last_event_log.dig(:root, :id))
root = last_event_log.fetch(:current)
assert_hash_schema!({ id: Integer, name: 'SumDivisionsByTwo', desc: nil }, root)
# 1st division event_log
#
{
root: root,
parent: root,
current: { id: Integer, name: 'Division', desc: nil },
result: { kind: :failure, type: :invalid_arg, value: 'num1 must be numeric', source: Division }
}.then { |spec| assert_event_log_record(result, 0, spec) }
# 2nd division event_logs
#
refute_equal(
result.event_logs[:records][0].dig(:current, :id),
result.event_logs[:records][1].dig(:current, :id)
)
{
root: root,
parent: root,
current: { id: Integer, name: 'Division', desc: nil },
result: { kind: :success, type: :ok, value: [20, 2], source: Division }
}.then { |spec| assert_event_log_record(result, 1, spec) }
{
root: root,
parent: { id: Integer, name: 'CheckForZeros', desc: nil },
current: { id: Integer, name: 'DetectZero', desc: nil },
result: { kind: :failure, type: :not_zero, value: nil, source: nil }
}.then { |spec| assert_event_log_record(result, 2, spec) }
{
root: root,
parent: { id: Integer, name: 'Division', desc: nil },
current: { id: Integer, name: 'CheckForZeros', desc: nil },
result: { kind: :failure, type: :no_zeros, value: nil, source: nil }
}.then { |spec| assert_event_log_record(result, 3, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: 'Division', desc: nil },
result: { kind: :success, type: :division_completed, value: 10, source: Division },
and_then: { type: :method, arg: 'useless_arg', method_name: :divide }
}.then { |spec| assert_event_log_record(result, 4, spec) }
# 3rd division event_logs
#
refute_equal(
result.event_logs[:records][4].dig(:current, :id),
result.event_logs[:records][5].dig(:current, :id)
)
{
root: root,
parent: root,
current: { id: Integer, name: 'Division', desc: nil },
result: { kind: :success, type: :ok, value: [0, 2], source: Division }
}.then { |spec| assert_event_log_record(result, 5, spec) }
{
root: root,
parent: { id: Integer, name: 'CheckForZeros', desc: nil },
current: { id: Integer, name: 'DetectZero', desc: nil },
result: { kind: :failure, type: :not_zero, value: nil, source: nil }
}.then { |spec| assert_event_log_record(result, 6, spec) }
{
root: root,
parent: { id: Integer, name: 'Division', desc: nil },
current: { id: Integer, name: 'CheckForZeros', desc: nil },
result: { kind: :success, type: :num1_is_zero, value: nil, source: nil }
}.then { |spec| assert_event_log_record(result, 7, spec) }
{
root: root,
parent: root,
current: { id: Integer, name: 'Division', desc: nil },
result: { kind: :success, type: :division_completed, value: 0, source: Division },
and_then: { type: :method, arg: 'useless_arg', method_name: :divide }
}.then { |spec| assert_event_log_record(result, 8, spec) }
# Final result event_log
{
root: root,
parent: root,
current: root,
result: { kind: :failure, type: :errors, value: ['num1 must be numeric'] }
}.then { |spec| assert_event_log_record(result, 9, spec) }
assert_equal(10, result.event_logs[:records].size)
assert_equal(8, result.event_logs[:records].map { _1.dig(:current, :id) }.uniq.size)
assert_equal(10, result.event_logs[:records].map { _1[:time] }.tap { assert_equal(_1.sort, _1) }.uniq.size)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/instance/recursion_test.rb 0000664 0000000 0000000 00000002337 14606620746 0033061 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithSourceInstanceRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
class Fibonacci
include Solid::Result.mixin
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |number|
fibonacci = number <= 1 ? number : call(number - 1).value + call(number - 2).value
Success(:fibonacci, fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Failure(:not_a_number, 'input must be numeric')
input.negative? and return Failure(:negative_number, 'number cannot be negative')
Success(:number_gte_zero, input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.new.call('1')
failure2 = Fibonacci.new.call(-1)
fibonacci0 = Fibonacci.new.call(0)
fibonacci1 = Fibonacci.new.call(1)
fibonacci2 = Fibonacci.new.call(2)
assert_event_logs(failure1, size: 1)
assert_event_logs(failure2, size: 1)
assert_event_logs(fibonacci0, size: 2)
assert_event_logs(fibonacci1, size: 2)
assert_event_logs(fibonacci2, size: 6)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/singleton/ 0000775 0000000 0000000 00000000000 14606620746 0027655 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/singleton/flat_test.rb 0000664 0000000 0000000 00000004457 14606620746 0032201 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithSourceSingletonFlatTest < Minitest::Test
include SolidResultEventLogAssertions
module Division
extend self, Solid::Result.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, 'num2 must be numeric')
Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Success(:ok, numbers)
end
def divide((num1, num2))
Success(:ok, num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.call('4', 2)
result2 = Division.call(4, '2')
result3 = Division.call(4, 0)
result4 = Division.call(4, 2)
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.call('4', 2) }
t2 = Thread.new { Division.call(4, '2') }
t3 = Thread.new { Division.call(4, 0) }
t4 = Thread.new { Division.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
result2 = Division.call(4, 2)
assert_event_logs(result1, size: 2)
assert_event_logs(result2, size: 3)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.call(4, 2)
result2 = Division.call(4, 0)
assert_event_logs(result1, size: 3)
assert_event_logs(result2, size: 2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/singleton/nested_test.rb 0000664 0000000 0000000 00000014765 14606620746 0032540 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithSourceSingletonNestedTest < Minitest::Test
include SolidResultEventLogAssertions
module CheckForZeros
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(numbers)
Solid::Result.event_logs(name: 'CheckForZeros') do
Given(numbers)
.and_then(:detect_zero, index: 1)
.and_then(:detect_zero, index: 0)
.then { _1.success?(:_continue_) ? Failure(:no_zeros, numbers) : _1 }
end
end
private
def detect_zero(numbers, ref)
index = ref.fetch(:index)
numbers[index].zero? ? Success(:"number#{index + 1}_is_zero", numbers) : Continue(numbers)
end
end
module Division
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(num1, num2)
Solid::Result.event_logs(name: 'Division') do
Given([num1, num2])
.and_then(:validate_numbers)
.and_then(:check_for_zeros)
.and_then(:divide)
end
end
private
def validate_numbers((num1, num2))
num1.is_a?(Numeric) or return Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Failure(:invalid_arg, 'num2 must be numeric')
Continue([num1, num2])
end
def check_for_zeros(numbers)
CheckForZeros.call(numbers).handle do |on|
on[:no_zeros] { Continue(numbers) }
on[:number1_is_zero] { Success(:division_completed, 0) }
on[:number2_is_zero] { Failure(:division_by_zero, 'num2 cannot be zero') }
end
end
def divide((num1, num2))
Success(:division_completed, num1 / num2)
end
end
module SumDivisionsByTwo
extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(*numbers)
Solid::Result.event_logs(name: 'SumDivisionsByTwo') do
Given(numbers)
.and_then(:divide_numbers_by_two)
.and_then(:sum_divisions)
end
end
private
def divide_numbers_by_two(numbers)
divisions = numbers.map { Division.call(_1, 2) }
Continue(divisions)
end
def sum_divisions(divisions)
if divisions.any?(&:failure?)
Failure(:errors, divisions.select(&:failure?).map(&:value))
else
Success(:sum, divisions.sum(&:value))
end
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.call('30', '20', '10')
result2 = SumDivisionsByTwo.call(30, '20', '10')
result3 = SumDivisionsByTwo.call(30, 20, '10')
result4 = SumDivisionsByTwo.call(30, 20, 10)
assert_event_logs(result1, size: 9)
assert_event_logs(result2, size: 15)
assert_event_logs(result3, size: 21)
assert_event_logs(result4, size: 27)
{
root: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
parent: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
current: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
result: { kind: :success, type: :_given_, value: %w[30 20 10] }
}.then { |spec| assert_event_log_record(result1, 0, spec) }
assert_equal(
[0, [[1, []], [2, []], [3, []]]],
result1.event_logs[:metadata][:ids][:tree]
)
{
root: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
parent: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
current: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
result: { kind: :success, type: :_given_, value: [30, '20', '10'] }
}.then { |spec| assert_event_log_record(result2, 0, spec) }
assert_equal(
[0, [[1, [[2, []]]], [3, []], [4, []]]],
result2.event_logs[:metadata][:ids][:tree]
)
{
root: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
parent: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
current: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
result: { kind: :success, type: :_given_, value: [30, 20, '10'] }
}.then { |spec| assert_event_log_record(result3, 0, spec) }
assert_equal(
[0, [[1, [[2, []]]], [3, [[4, []]]], [5, []]]],
result3.event_logs[:metadata][:ids][:tree]
)
{
root: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
parent: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
current: { id: 0, name: 'SumDivisionsByTwo', desc: nil },
result: { kind: :success, type: :_given_, value: [30, 20, 10] }
}.then { |spec| assert_event_log_record(result4, 0, spec) }
assert_equal(
[0, [[1, [[2, []]]], [3, [[4, []]]], [5, [[6, []]]]]],
result4.event_logs[:metadata][:ids][:tree]
)
assert_predicate(result1.event_logs[:records][0][:and_then], :empty?)
assert_predicate(result1.event_logs[:records][1][:and_then], :empty?)
assert_equal(:validate_numbers, result1.event_logs[:records][2][:and_then][:method_name])
assert_predicate(result1.event_logs[:records][3][:and_then], :empty?)
assert_equal(:validate_numbers, result1.event_logs[:records][4][:and_then][:method_name])
assert_predicate(result1.event_logs[:records][5][:and_then], :empty?)
assert_equal(:validate_numbers, result1.event_logs[:records][6][:and_then][:method_name])
assert_equal(:divide_numbers_by_two, result1.event_logs[:records][7][:and_then][:method_name])
assert_equal(:sum_divisions, result1.event_logs[:records][8][:and_then][:method_name])
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 9)
assert_event_logs(result2, size: 15)
assert_event_logs(result3, size: 21)
assert_event_logs(result4, size: 27)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
result2 = SumDivisionsByTwo.call(30, 20, 10)
assert_event_logs(result1, size: 21)
assert_event_logs(result2, size: 27)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
result2 = SumDivisionsByTwo.call(30, 20, '10')
assert_event_logs(result1, size: 27)
assert_event_logs(result2, size: 21)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/with_source/singleton/recursion_test.rb 0000664 0000000 0000000 00000002322 14606620746 0033251 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithSourceSingletonRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
module Fibonacci
extend self, Solid::Result.mixin
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |number|
fibonacci = number <= 1 ? number : call(number - 1).value + call(number - 2).value
Success(:fibonacci, fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Failure(:invalid_input, 'input must be numeric')
input.negative? and return Failure(:invalid_number, 'number cannot be negative')
Success(:positive_number, input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.call('1')
failure2 = Fibonacci.call(-1)
fibonacci0 = Fibonacci.call(0)
fibonacci1 = Fibonacci.call(1)
fibonacci2 = Fibonacci.call(2)
assert_event_logs(failure1, size: 1)
assert_event_logs(failure2, size: 1)
assert_event_logs(fibonacci0, size: 2)
assert_event_logs(fibonacci1, size: 2)
assert_event_logs(fibonacci2, size: 6)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/ 0000775 0000000 0000000 00000000000 14606620746 0026403 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/instance/ 0000775 0000000 0000000 00000000000 14606620746 0030207 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/instance/flat_test.rb 0000664 0000000 0000000 00000004737 14606620746 0032534 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithoutSourceInstanceFlatTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
include Solid::Result.mixin
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num2 must be numeric')
Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Solid::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
Solid::Result::Success(:ok, num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.new.call('4', 2)
result2 = Division.new.call(4, '2')
result3 = Division.new.call(4, 0)
result4 = Division.new.call(4, 2)
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.new.call('4', 2) }
t2 = Thread.new { Division.new.call(4, '2') }
t3 = Thread.new { Division.new.call(4, 0) }
t4 = Thread.new { Division.new.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
result2 = Division.new.call(4, 2)
assert_event_logs(result1, size: 2)
assert_event_logs(result2, size: 3)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.new.call(4, 2)
result2 = Division.new.call(4, 0)
assert_event_logs(result1, size: 3)
assert_event_logs(result2, size: 2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/instance/nested_test.rb 0000664 0000000 0000000 00000006104 14606620746 0033056 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithoutSourceInstanceNestedTest < Minitest::Test
include SolidResultEventLogAssertions
class Division
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num2 must be numeric')
Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
Solid::Result::Success(:ok, num1 / num2)
end
end
class SumDivisionsByTwo
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Solid::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
else
Solid::Result::Success(:sum, divisions.sum(&:value))
end
end
end
private
def divide_by_two(num)
Division.new.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.new.call('30', '20', '10')
result2 = SumDivisionsByTwo.new.call(30, '20', '10')
result3 = SumDivisionsByTwo.new.call(30, 20, '10')
result4 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.new.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.new.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.new.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.new.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
result2 = SumDivisionsByTwo.new.call(30, 20, 10)
assert_event_logs(result1, size: 8)
assert_event_logs(result2, size: 10)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
result2 = SumDivisionsByTwo.new.call(30, 20, '10')
assert_event_logs(result1, size: 10)
assert_event_logs(result2, size: 8)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/instance/recursion_test.rb 0000664 0000000 0000000 00000002375 14606620746 0033613 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithoutSourceInstanceRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
class Fibonacci
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |number|
fibonacci = number <= 1 ? number : call(number - 1).value + call(number - 2).value
Solid::Result::Success(:fibonacci, fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Solid::Result::Failure(:invalid_input, 'input must be numeric')
input.negative? and return Solid::Result::Failure(:invalid_number, 'number cannot be negative')
Solid::Result::Success(:positive_number, input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.new.call('1')
failure2 = Fibonacci.new.call(-1)
fibonacci0 = Fibonacci.new.call(0)
fibonacci1 = Fibonacci.new.call(1)
fibonacci2 = Fibonacci.new.call(2)
assert_event_logs(failure1, size: 1)
assert_event_logs(failure2, size: 1)
assert_event_logs(fibonacci0, size: 2)
assert_event_logs(fibonacci1, size: 2)
assert_event_logs(fibonacci2, size: 6)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/singleton/ 0000775 0000000 0000000 00000000000 14606620746 0030405 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/singleton/flat_test.rb 0000664 0000000 0000000 00000004641 14606620746 0032724 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithoutSourceSingletonFlatTest < Minitest::Test
include SolidResultEventLogAssertions
module Division
extend self
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num2 must be numeric')
Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Solid::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
Solid::Result::Success(:ok, num1 / num2)
end
end
test 'the tracking without nesting' do
result1 = Division.call('4', 2)
result2 = Division.call(4, '2')
result3 = Division.call(4, 0)
result4 = Division.call(4, 2)
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the tracking without nesting in different threads' do
t1 = Thread.new { Division.call('4', 2) }
t2 = Thread.new { Division.call(4, '2') }
t3 = Thread.new { Division.call(4, 0) }
t4 = Thread.new { Division.call(4, 2) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 1)
assert_event_logs(result2, size: 1)
assert_event_logs(result3, size: 2)
assert_event_logs(result4, size: 3)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
result2 = Division.call(4, 2)
assert_event_logs(result1, size: 2)
assert_event_logs(result2, size: 3)
end
test 'an exception handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.call(4, 2)
result2 = Division.call(4, 0)
assert_event_logs(result1, size: 3)
assert_event_logs(result2, size: 2)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/singleton/nested_test.rb 0000664 0000000 0000000 00000006065 14606620746 0033262 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithoutSourceSingletonNestedTest < Minitest::Test
include SolidResultEventLogAssertions
module Division
extend self
def call(num1, num2)
Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
end
end
private
def validate_numbers(num1, num2)
num1.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num1 must be numeric')
num2.is_a?(Numeric) or return Solid::Result::Failure(:invalid_arg, 'num2 must be numeric')
Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
Solid::Result::Success(:ok, num1 / num2)
end
end
module SumDivisionsByTwo
extend self
def call(*numbers)
Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
Solid::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
else
Solid::Result::Success(:sum, divisions.sum(&:value))
end
end
end
private
def divide_by_two(num)
Division.call(num, 2)
end
end
test 'nested event_logs tracking' do
result1 = SumDivisionsByTwo.call('30', '20', '10')
result2 = SumDivisionsByTwo.call(30, '20', '10')
result3 = SumDivisionsByTwo.call(30, 20, '10')
result4 = SumDivisionsByTwo.call(30, 20, 10)
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'nested event_logs tracking in different threads' do
t1 = Thread.new { SumDivisionsByTwo.call('30', '20', '10') }
t2 = Thread.new { SumDivisionsByTwo.call(30, '20', '10') }
t3 = Thread.new { SumDivisionsByTwo.call(30, 20, '10') }
t4 = Thread.new { SumDivisionsByTwo.call(30, 20, 10) }
result1 = t1.value
result2 = t2.value
result3 = t3.value
result4 = t4.value
assert_event_logs(result1, size: 4)
assert_event_logs(result2, size: 6)
assert_event_logs(result3, size: 8)
assert_event_logs(result4, size: 10)
end
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
result2 = SumDivisionsByTwo.call(30, 20, 10)
assert_event_logs(result1, size: 8)
assert_event_logs(result2, size: 10)
end
test 'an exception error handling' do
assert_raises(NotImplementedError) do
Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
result2 = SumDivisionsByTwo.call(30, 20, '10')
assert_event_logs(result1, size: 10)
assert_event_logs(result2, size: 8)
end
end
solid-result-2.0.0/test/solid/result/event_logs/enabled/without_source/singleton/recursion_test.rb 0000664 0000000 0000000 00000002374 14606620746 0034010 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsEnabledWithoutSourceSingletonRecursionTest < Minitest::Test
include SolidResultEventLogAssertions
module Fibonacci
extend self
def call(input)
Solid::Result.event_logs do
require_valid_number(input).and_then do |number|
fibonacci = number <= 1 ? number : call(number - 1).value + call(number - 2).value
Solid::Result::Success(:fibonacci, fibonacci)
end
end
end
private
def require_valid_number(input)
input.is_a?(Numeric) or return Solid::Result::Failure(:invalid_input, 'input must be numeric')
input.negative? and return Solid::Result::Failure(:invalid_number, 'number cannot be negative')
Solid::Result::Success(:positive_number, input)
end
end
test 'event_logs inside a recursion' do
failure1 = Fibonacci.call('1')
failure2 = Fibonacci.call(-1)
fibonacci0 = Fibonacci.call(0)
fibonacci1 = Fibonacci.call(1)
fibonacci2 = Fibonacci.call(2)
assert_event_logs(failure1, size: 1)
assert_event_logs(failure2, size: 1)
assert_event_logs(fibonacci0, size: 2)
assert_event_logs(fibonacci1, size: 2)
assert_event_logs(fibonacci2, size: 6)
end
end
solid-result-2.0.0/test/solid/result/event_logs/listener_test.rb 0000664 0000000 0000000 00000001062 14606620746 0025136 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid::Result::EventLogs
class ListenerTest < Minitest::Test
module ModuleListener
extend Listener
end
class ClassListener
include Listener
end
test '.around_event_logs?' do
refute_predicate ModuleListener, :around_event_logs?
refute_predicate ClassListener, :around_event_logs?
end
test '.around_and_then?' do
refute_predicate ModuleListener, :around_and_then?
refute_predicate ClassListener, :around_and_then?
end
end
end
solid-result-2.0.0/test/solid/result/event_logs/listeners_test.rb 0000664 0000000 0000000 00000015200 14606620746 0025320 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid::Result::EventLogs
class ListenersTest < Minitest::Test
include SolidResultEventLogAssertions
module AroundListener
extend Solid::Result::EventLogs::Listener
def self.around_and_then?
true
end
def self.around_event_logs?
true
end
class << self
attr_reader :memo
def new
tap { @memo = Hash.new { |hash, key| hash[key] = [] } }
end
def around_event_logs(scope:)
memo[:around_event_logs] << scope
yield
end
def around_and_then(scope:, and_then:)
memo[:around_and_then] << { scope: scope, and_then: and_then }
yield
end
end
end
module InspectListener
extend Solid::Result::EventLogs::Listener
class << self
attr_reader :memo
def new
tap { @memo = Hash.new { |hash, key| hash[key] = [] } }
end
def on_start(scope:)
memo[:on_start] << scope
end
def on_record(record:)
memo[:on_record] << record
end
def on_finish(event_logs:)
memo[:on_finish] << event_logs
end
def before_interruption(exception:, event_logs:)
memo[:before_interruption] << { exception: exception, event_logs: event_logs }
end
end
end
class Division
include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Solid::Result.event_logs(name: 'Division') do
Given([arg1, arg2])
.and_then(:require_numbers)
.and_then(:check_for_zeros)
.and_then(:divide)
end
end
private
ValidNumber = ->(arg) { arg.is_a?(Numeric) && (!arg.respond_to?(:finite?) || arg.finite?) }
def require_numbers((arg1, arg2))
ValidNumber[arg1] or return Failure(:invalid_arg, 'arg1 must be a valid number')
ValidNumber[arg2] or return Failure(:invalid_arg, 'arg2 must be a valid number')
Continue([arg1, arg2])
end
def check_for_zeros(numbers)
numbers.first.zero? ? Success(:division_completed, 0) : Continue(numbers)
end
def divide((num1, num2))
Success(:division_completed, num1 / num2)
end
end
test 'one listener (without interruption)' do
original_listener = Solid::Result.config.event_logs.listener
Solid::Result.config.event_logs.listener = Listeners[InspectListener]
result = Division.new.call(10, 2)
scope = { id: 0, name: 'Division', desc: nil }
assert_equal([scope], InspectListener.memo[:on_start])
result.event_logs[:records].each_with_index do |record, index|
assert_equal(record, InspectListener.memo[:on_record][index])
end
assert_equal(result.event_logs, InspectListener.memo[:on_finish].first)
ensure
Solid::Result.config.event_logs.listener = original_listener
end
test 'multiple listeners' do
original_listener = Solid::Result.config.event_logs.listener
Solid::Result.config.event_logs.listener = Listeners[InspectListener, AroundListener]
result = Division.new.call(10, 2)
scope = { id: 0, name: 'Division', desc: nil }
assert_equal([scope], InspectListener.memo[:on_start])
assert_empty(InspectListener.memo[:around_event_logs])
assert_empty(InspectListener.memo[:around_and_then])
assert_equal([scope], AroundListener.memo[:around_event_logs])
[
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :require_numbers } },
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :check_for_zeros } },
{ scope: scope, and_then: { type: :method, arg: nil, method_name: :divide } }
].each_with_index do |and_then, index|
assert_equal(and_then, AroundListener.memo[:around_and_then][index])
end
result.event_logs[:records].each_with_index do |record, index|
assert_equal(record, InspectListener.memo[:on_record][index])
end
assert_equal(result.event_logs, InspectListener.memo[:on_finish].first)
ensure
Solid::Result.config.event_logs.listener = original_listener
end
test 'multiple listeners (with interruption)' do
original_listener = Solid::Result.config.event_logs.listener
Solid::Result.config.event_logs.listener = Listeners[InspectListener, AroundListener]
assert_raises(ZeroDivisionError, 'divided by 0') { Division.new.call(10, 0) }
on_record = InspectListener.memo[:on_record]
before_interruption = InspectListener.memo[:before_interruption].first
assert_event_logs!(before_interruption[:event_logs], size: 3)
assert_equal(on_record, before_interruption[:event_logs][:records])
ensure
Solid::Result.config.event_logs.listener = original_listener
end
module AroundAndThenListener
extend Solid::Result::EventLogs::Listener
def self.around_and_then?
true
end
end
test 'multiple around_and_then? listeners' do
original_listener = Solid::Result.config.event_logs.listener
assert_raises ArgumentError, 'Only one listener can have around_and_then? == true' do
Listeners[
AroundAndThenListener,
InspectListener,
AroundListener
]
end
ensure
Solid::Result.config.event_logs.listener = original_listener
end
module AroundEventLogsListener
extend Solid::Result::EventLogs::Listener
def self.around_event_logs?
true
end
end
test 'multiple around_event_logs? listeners' do
original_listener = Solid::Result.config.event_logs.listener
assert_raises ArgumentError, 'only one listener can have around_event_logs? == true' do
Listeners[
AroundListener,
InspectListener,
AroundEventLogsListener
]
end
ensure
Solid::Result.config.event_logs.listener = original_listener
end
test 'invalid argument (empty)' do
original_listener = Solid::Result.config.event_logs.listener
assert_raises ArgumentError, 'listeners must be a list of Solid::Result::EventLogs::Listener' do
Listeners[]
end
ensure
Solid::Result.config.event_logs.listener = original_listener
end
test 'invalid argument (non Listener)' do
original_listener = Solid::Result.config.event_logs.listener
assert_raises ArgumentError, 'listeners must be a list of Solid::Result::EventLogs::Listener' do
Listeners[String]
end
ensure
Solid::Result.config.event_logs.listener = original_listener
end
end
end
solid-result-2.0.0/test/solid/result/event_logs/tree_test.rb 0000664 0000000 0000000 00000013526 14606620746 0024260 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid::Result::EventLogs
class TreeTest < Minitest::Test
test '#root' do
tree = Tree.new(:root1)
assert_equal(:root1, tree.root.value)
assert_equal('#', tree.root.inspect)
end
test '#root_value' do
tree = Tree.new(:root2)
assert_equal(:root2, tree.root_value)
end
test '#parent_value' do
tree = Tree.new(:root)
assert_equal(:root, tree.parent_value)
tree.insert!(:child)
tree.insert!(:grandchild)
assert_equal(:child, tree.parent_value)
assert_equal('#', tree.current.parent.inspect)
end
test '#current_value' do
tree = Tree.new(:root)
tree.insert!(:child)
tree.insert!('grandchild')
assert_equal('grandchild', tree.current_value)
assert_equal('#', tree.current.inspect)
end
test '#insert' do
tree = Tree.new(:root)
tree.insert(:child)
assert_same(tree.root, tree.current)
end
test '#insert!' do
tree = Tree.new(:root)
tree.insert!('child')
refute_same(tree.root, tree.current)
assert_equal('child', tree.current.value)
end
test '#move_up!' do
tree = Tree.new('root')
tree.insert!('child')
tree.insert!('grandchild')
assert_equal('grandchild', tree.current_value)
tree.move_up!
assert_equal('child', tree.current_value)
tree.move_down!
tree.move_up!(2)
assert_equal('root', tree.current_value)
tree.move_down!(2)
tree.move_up!(100)
assert_equal('root', tree.current_value)
end
test '#move_down!' do
tree = Tree.new('root')
tree.insert!('child')
tree.insert!('grandchild')
tree.insert!('great-grandchild')
assert_equal('great-grandchild', tree.current_value)
assert_predicate(tree.current, :leaf?)
tree.move_to_root!
assert_predicate(tree.current, :root?)
tree.move_down!
assert_equal('child', tree.current_value)
assert_predicate(tree.current, :node?)
refute_predicate(tree.current, :leaf?)
tree.move_down!(2)
assert_equal('great-grandchild', tree.current_value)
tree.move_to_root!
tree.insert!('new-child')
tree.move_up!
assert_equal(4, tree.size)
tree.move_down!
assert_equal('new-child', tree.current_value)
tree.move_to_root!
tree.move_down!(index: 0)
assert_equal('child', tree.current_value)
tree.move_down!(index: 100)
assert_equal('child', tree.current_value)
end
test '#ids' do
tree = Tree.new('root')
tree.insert!('child')
tree.insert!('grandchild')
tree.insert!('great-grandchild')
tree.move_to_root!
tree.insert!('new-child')
tree.insert!('new-grandchild')
tree.move_up!
tree.insert!('new-grandchild__child')
tree.move_to_root!
tree.insert!('new-new-child')
assert_equal(
[0, [
[1, [[2, [[3, []]]]]],
[4, [
[5, []],
[6, []]
]],
[7, []]
]],
tree.ids
)
tree.move_to_root!
assert(tree.current.id.zero? && tree.current.value == 'root')
tree.move_down!(index: 0)
assert(tree.current.id == 1 && tree.current.value == 'child')
tree.move_down!(index: 0)
assert(tree.current.id == 2 && tree.current.value == 'grandchild')
tree.move_down!(index: 0)
assert(tree.current.id == 3 && tree.current.value == 'great-grandchild')
tree.move_to_root!
tree.move_down!(index: 1)
assert(tree.current.id == 4 && tree.current.value == 'new-child')
tree.move_down!(index: 0)
assert(tree.current.id == 5 && tree.current.value == 'new-grandchild')
tree.move_up!
tree.move_down!
assert(tree.current.id == 6 && tree.current.value == 'new-grandchild__child')
tree.move_to_root!
tree.move_down!
assert(tree.current.id == 7 && tree.current.value == 'new-new-child')
end
test '#ids_matrix' do
tree = Tree.new('root')
tree.insert!('child')
tree.insert!('grandchild')
tree.insert!('great-grandchild')
tree.move_to_root!
tree.insert!('new-child')
tree.insert!('new-grandchild')
tree.move_up!
tree.insert!('new-grandchild__child')
tree.move_to_root!
tree.insert!('new-new-child')
assert_equal(
{ 0 => [0, 0], 1 => [1, 1], 2 => [1, 2], 3 => [1, 3], 4 => [2, 1], 5 => [2, 2], 6 => [2, 3], 7 => [3, 1] },
tree.ids_matrix
)
end
test '#ids_list' do
tree = Tree.new('root')
tree.insert!('child')
tree.insert!('grandchild')
tree.insert!('great-grandchild')
tree.move_to_root!
tree.insert!('new-child')
tree.insert!('new-grandchild')
tree.move_up!
tree.insert!('new-grandchild__child')
tree.move_to_root!
tree.insert!('new-new-child')
assert_equal(
[0, 1, 2, 3, 4, 5, 6, 7],
tree.ids_list
)
end
test '#ids_level_parent' do
tree = Tree.new('root')
tree.insert!('child')
tree.insert!('grandchild')
tree.insert!('great-grandchild')
tree.move_to_root!
tree.insert!('new-child')
tree.insert!('new-grandchild')
tree.move_up!
tree.insert!('new-grandchild__child')
tree.move_to_root!
tree.insert!('new-new-child')
assert_equal(
{
0 => [0, 0],
1 => [1, 0],
2 => [2, 1],
3 => [3, 2],
4 => [1, 0],
5 => [2, 4],
6 => [2, 4],
7 => [1, 0]
},
tree.ids_level_parent
)
end
end
end
solid-result-2.0.0/test/solid/result/event_logs_test.rb 0000664 0000000 0000000 00000000707 14606620746 0023316 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::EventLogsTest < Minitest::Test
test 'the unexpected outcome error' do
err = assert_raises(Solid::Result::Error::UnexpectedOutcome) do
Solid::Result.event_logs { 1 }
end
assert_equal(
'Unexpected outcome: 1. The event_logs must return this object wrapped by ' \
'Solid::Result::Success or Solid::Result::Failure',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/ 0000775 0000000 0000000 00000000000 14606620746 0022267 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/mixin_constants_test.rb 0000664 0000000 0000000 00000001513 14606620746 0027073 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::Expectations::MixinConstantsTest < Minitest::Test
class IncludingInClass
include Solid::Result::Expectations.mixin
end
module IncludingInModule
include Solid::Result::Expectations.mixin
end
class ExtendingInClass
extend Solid::Result::Expectations.mixin
end
module ExtendingInModule
extend Solid::Result::Expectations.mixin
end
test 'Solid::Result::Expectations.mixin sets a constant in all classes/modules' do
assert IncludingInClass.const_defined?(:ResultExpectationsMixin, false)
assert IncludingInModule.const_defined?(:ResultExpectationsMixin, false)
assert ExtendingInClass.const_defined?(:ResultExpectationsMixin, false)
assert ExtendingInModule.const_defined?(:ResultExpectationsMixin, false)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/ 0000775 0000000 0000000 00000000000 14606620746 0024622 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/failure/ 0000775 0000000 0000000 00000000000 14606620746 0026251 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/failure/type/ 0000775 0000000 0000000 00000000000 14606620746 0027232 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/failure/type/invalid_type_test.rb 0000664 0000000 0000000 00000002117 14606620746 0033306 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceFailureInvalidTypeTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err1, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:err2, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:ok, number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call('10', 2)
end
assert_equal(
'type :err1 is not allowed. Allowed types: :err',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/failure/type_and_value/ 0000775 0000000 0000000 00000000000 14606620746 0031250 5 ustar 00root root 0000000 0000000 invalid_type_test.rb 0000664 0000000 0000000 00000002216 14606620746 0035245 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceFailureInvalidTypeAndValueTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
failure: {
err1: String,
err2: String
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err1, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:err2, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:ok, number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
assert_equal(
'type :err is not allowed. Allowed types: :err1, :err2',
err.message
)
end
end
invalid_value_test.rb 0000664 0000000 0000000 00000001643 14606620746 0035403 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, :'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, :'arg2 must be numeric')
return Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Success(:division_completed, (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, '2')
end
assert_equal(
'value :"arg2 must be numeric" is not allowed for :invalid_arg type',
err.message
)
end
end
pattern_matching_error_test.rb 0000664 0000000 0000000 00000002107 14606620746 0037315 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
failure: {
invalid_arg: String,
division_by_zero: ->(value) do
case value
in String then true
end
end
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
return Failure(:division_by_zero, :'arg2 must not be zero') if arg2.zero?
Success(:division_completed, (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 0)
end
assert_match(
Regexp.new(
'value :"arg2 must not be zero" is not allowed for :division_by_zero type ' \
'\(.*arg2 must not be zero.*\)'
),
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/failure/type_and_value_test.rb 0000664 0000000 0000000 00000011017 14606620746 0032634 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceFailureTypeAndValueTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
failure: {
invalid_arg: String,
division_by_zero: ->(value) { value.is_a?(String) }
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:invalid_arg)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:invalid_arg) { increment += 1 }
.on_failure(:division_by_zero) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:invalid_arg) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err3.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/failure/type_test.rb 0000664 0000000 0000000 00000007004 14606620746 0030617 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceFailureTypeTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:err, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:err)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:err) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:err) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.success(:err) { increment += 1 }
on.failure(:err) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :err',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:bar) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :bar is not allowed. Allowed types: :err',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :err',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :err',
err1.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :err',
err2.message
)
end
test 'does not handle all cases' do
err = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :err',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/failure/types/ 0000775 0000000 0000000 00000000000 14606620746 0027415 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/failure/types/invalid_type_test.rb 0000664 0000000 0000000 00000002140 14606620746 0033465 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceFailureInvalidTypesTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
failure: %i[err1 err2]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err1, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:err2, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:ok, number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
assert_equal(
'type :err is not allowed. Allowed types: :err1, :err2',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/failure/types_test.rb 0000664 0000000 0000000 00000012541 14606620746 0031004 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceFailureTypesTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:invalid_arg)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:invalid_arg) { increment += 1 }
.on_failure(:division_by_zero) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:invalid_arg) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :invalid_arg',
err4.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success/ 0000775 0000000 0000000 00000000000 14606620746 0026272 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success/type/ 0000775 0000000 0000000 00000000000 14606620746 0027253 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success/type/invalid_type_test.rb 0000664 0000000 0000000 00000001476 14606620746 0033336 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessInvalidTypeTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: :ok
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
return Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Success(:division_completed, arg1 / arg2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success/type_and_value/ 0000775 0000000 0000000 00000000000 14606620746 0031271 5 ustar 00root root 0000000 0000000 invalid_type_test.rb 0000664 0000000 0000000 00000001625 14606620746 0035271 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: {
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
return Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Success(:ok, arg1 / arg2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :ok is not allowed. Allowed types: :division_completed',
err.message
)
end
end
invalid_value_test.rb 0000664 0000000 0000000 00000001651 14606620746 0035423 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: {
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
return Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Success(:division_completed, (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
assert_equal(
'value "5" is not allowed for :division_completed type',
err.message
)
end
end
pattern_matching_error_test.rb 0000664 0000000 0000000 00000002017 14606620746 0037336 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: {
division_completed: ->(value) do
case value
in (Integer | Float) then true
end
end
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
return Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Success(:division_completed, (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
assert_match(
Regexp.new(
'value "5" is not allowed for :division_completed type ' \
'\(.*5.*\)'
),
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success/type_and_value_test.rb 0000664 0000000 0000000 00000010727 14606620746 0032664 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessTypeAndValueTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: {
numbers: Array,
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success/type_test.rb 0000664 0000000 0000000 00000006240 14606620746 0030641 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessTypeTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: :ok
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:ok, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:ok)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:ok) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:ok) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:ok) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :ok',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :foo is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :ok',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :foo is not allowed. Allowed types: :ok',
err.message
)
end
test 'does not handle all cases' do
err = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :ok',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success/types/ 0000775 0000000 0000000 00000000000 14606620746 0027436 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success/types/invalid_type_test.rb 0000664 0000000 0000000 00000002200 14606620746 0033503 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessInvalidTypesTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: %i[ok1 ok2 ok3]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:ok1, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok2, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:ok, number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :ok is not allowed. Allowed types: :ok1, :ok2, :ok3',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success/types_test.rb 0000664 0000000 0000000 00000012415 14606620746 0031025 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessTypesTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: %i[numbers division_completed]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:numbers) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err4.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success_and_failure/ 0000775 0000000 0000000 00000000000 14606620746 0030623 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success_and_failure/mixed/ 0000775 0000000 0000000 00000000000 14606620746 0031731 5 ustar 00root root 0000000 0000000 type_and_value_with_types_test.rb 0000664 0000000 0000000 00000016406 14606620746 0040523 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success_and_failure/mixed # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: {
numbers: Array,
division_completed: Numeric
},
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
types_with_type_and_value_test.rb 0000664 0000000 0000000 00000016406 14606620746 0040523 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success_and_failure/mixed # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: %i[numbers division_completed],
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
type_and_value_test.rb 0000664 0000000 0000000 00000016444 14606620746 0035140 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/with_source/success_and_failure # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: {
numbers: Array,
division_completed: Numeric
},
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success_and_failure/type_test.rb 0000664 0000000 0000000 00000015073 14606620746 0033176 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypeTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: :ok,
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:err, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:err, 'arg2 must be numeric')
Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
Failure(:err, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:ok, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:ok)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:err)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:ok) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:err) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:ok) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:ok) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:err) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:err) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:division_completed)
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:division_by_zero)
end
assert_equal(
'type :division_by_zero is not allowed. Allowed types: :err',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:division_completed) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:invalid_arg) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :err',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :ok, :err',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:division_completed) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:division_by_zero) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :division_by_zero is not allowed. Allowed types: :err',
err2.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :ok, :err',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:ok) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:err) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:ok) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:err) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :err',
err1.message
)
assert_equal(
'You must handle all cases. This was not handled: :err',
err2.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err4.message
)
assert_equal(
'You must handle all cases. This was not handled: :err',
err5.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err6.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/with_source/success_and_failure/types_test.rb 0000664 0000000 0000000 00000016317 14606620746 0033363 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypesTest < Minitest::Test
class Divide
include Solid::Result::Expectations.mixin(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then(:validate_non_zero)
.and_then(:divide)
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Failure(:invalid_arg, 'arg2 must be numeric')
Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Success(:numbers, numbers) unless numbers.last.zero?
Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/ 0000775 0000000 0000000 00000000000 14606620746 0025352 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/failure/ 0000775 0000000 0000000 00000000000 14606620746 0027001 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/failure/type/ 0000775 0000000 0000000 00000000000 14606620746 0027762 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/failure/type/invalid_type_test.rb 0000664 0000000 0000000 00000002253 14606620746 0034037 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceFailureInvalidTypeTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err1, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, 'arg2 must be numeric')
Result::Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:ok, numbers) unless numbers.last.zero?
Result::Failure(:err2, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:ok, number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call('10', 2)
end
assert_equal(
'type :err1 is not allowed. Allowed types: :err',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/failure/type_and_value/ 0000775 0000000 0000000 00000000000 14606620746 0032000 5 ustar 00root root 0000000 0000000 invalid_type_test.rb 0000664 0000000 0000000 00000002352 14606620746 0035776 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceFailureInvalidTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: {
err1: String,
err2: String
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err1, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, 'arg2 must be numeric')
Result::Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:ok, numbers) unless numbers.last.zero?
Result::Failure(:err2, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:ok, number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
assert_equal(
'type :err is not allowed. Allowed types: :err1, :err2',
err.message
)
end
end
invalid_value_test.rb 0000664 0000000 0000000 00000001705 14606620746 0036132 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, :'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, :'arg2 must be numeric')
return Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, '2')
end
assert_equal(
'value :"arg2 must be numeric" is not allowed for :invalid_arg type',
err.message
)
end
end
pattern_matching_error_test.rb 0000664 0000000 0000000 00000002151 14606620746 0040044 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/failure/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: {
invalid_arg: String,
division_by_zero: ->(value) do
case value
in String then true
end
end
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Result::Failure(:division_by_zero, :'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 0)
end
assert_match(
Regexp.new(
'value :"arg2 must not be zero" is not allowed for :division_by_zero type ' \
'\(.*arg2 must not be zero.*\)'
),
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/failure/type_and_value_test.rb 0000664 0000000 0000000 00000011153 14606620746 0033365 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceFailureTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: {
invalid_arg: String,
division_by_zero: ->(value) { value.is_a?(String) }
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:numbers, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:invalid_arg)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:invalid_arg) { increment += 1 }
.on_failure(:division_by_zero) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:invalid_arg) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err3.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/failure/type_test.rb 0000664 0000000 0000000 00000007140 14606620746 0031350 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceFailureTypeTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, 'arg2 must be numeric')
Result::Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:ok, numbers) unless numbers.last.zero?
Result::Failure(:err, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:err)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:err) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:err) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.success(:err) { increment += 1 }
on.failure(:err) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :err',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:bar) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :bar is not allowed. Allowed types: :err',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :err',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :err',
err1.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :err',
err2.message
)
end
test 'does not handle all cases' do
err = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :err',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/failure/types/ 0000775 0000000 0000000 00000000000 14606620746 0030145 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/failure/types/invalid_type_test.rb 0000664 0000000 0000000 00000002264 14606620746 0034224 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceFailureInvalidTypesTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: %i[err1 err2]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err1, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, 'arg2 must be numeric')
Result::Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:ok, numbers) unless numbers.last.zero?
Failure(:err2, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:ok, number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
assert_equal(
'type :err is not allowed. Allowed types: :err1, :err2',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/failure/types_test.rb 0000664 0000000 0000000 00000012675 14606620746 0031544 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceFailureTypesTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:numbers, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, '2')
assert result.failure?(:invalid_arg)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 0)
result
.on_success { increment += 1 }
.on_failure { increment += 1 }
.on_failure(:invalid_arg) { increment += 1 }
.on_failure(:division_by_zero) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, '5').handle do |on|
on.success { increment += 1 }
on.failure { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
end
Divide.new.call(10, 0).handle do |on|
on.success { increment += 1 }
on.failure(:invalid_arg, :division_by_zero) { increment += 1 }
on.failure { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, '2')
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :error is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:invalid_arg) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(4, '2').handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :invalid_arg',
err4.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success/ 0000775 0000000 0000000 00000000000 14606620746 0027022 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success/type/ 0000775 0000000 0000000 00000000000 14606620746 0030003 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success/type/invalid_type_test.rb 0000664 0000000 0000000 00000001540 14606620746 0034056 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessInvalidTypeTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: :ok
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, arg1 / arg2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success/type_and_value/ 0000775 0000000 0000000 00000000000 14606620746 0032021 5 ustar 00root root 0000000 0000000 invalid_type_test.rb 0000664 0000000 0000000 00000001667 14606620746 0036027 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: {
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Result::Success(:ok, arg1 / arg2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :ok is not allowed. Allowed types: :division_completed',
err.message
)
end
end
invalid_value_test.rb 0000664 0000000 0000000 00000001713 14606620746 0036152 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: {
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
assert_equal(
'value "5" is not allowed for :division_completed type',
err.message
)
end
end
pattern_matching_error_test.rb 0000664 0000000 0000000 00000002061 14606620746 0040065 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success/type_and_value # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: {
division_completed: ->(value) do
case value
in (Integer | Float) then true
end
end
}
)
def call(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Result::Success(:division_completed, (arg1 / arg2).to_s)
end
end
test 'unexpected value error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
assert_match(
Regexp.new(
'value "5" is not allowed for :division_completed type ' \
'\(.*5.*\)'
),
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success/type_and_value_test.rb 0000664 0000000 0000000 00000011063 14606620746 0033406 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: {
numbers: Array,
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:numbers, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success/type_test.rb 0000664 0000000 0000000 00000006374 14606620746 0031401 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessTypeTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: :ok
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:ok, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:ok, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:ok)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:ok) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:ok) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:ok) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :ok',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :foo is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :ok',
err2.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :foo is not allowed. Allowed types: :ok',
err.message
)
end
test 'does not handle all cases' do
err = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :ok',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success/types/ 0000775 0000000 0000000 00000000000 14606620746 0030166 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success/types/invalid_type_test.rb 0000664 0000000 0000000 00000002334 14606620746 0034243 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessInvalidTypesTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: %i[ok1 ok2 ok3]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:ok1, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:ok2, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:ok, number1 / number2)
end
end
test 'unexpected type error' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
assert_equal(
'type :ok is not allowed. Allowed types: :ok1, :ok2, :ok3',
err.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success/types_test.rb 0000664 0000000 0000000 00000012551 14606620746 0031556 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessTypesTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: %i[numbers division_completed]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:numbers, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
end
test 'invalid result type' do
err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :numbers, :division_completed',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:numbers) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :division_completed',
err4.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success_and_failure/ 0000775 0000000 0000000 00000000000 14606620746 0031353 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success_and_failure/mixed/ 0000775 0000000 0000000 00000000000 14606620746 0032461 5 ustar 00root root 0000000 0000000 type_and_value_with_types_test.rb 0000664 0000000 0000000 00000016542 14606620746 0041254 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success_and_failure/mixed # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: {
numbers: Array,
division_completed: Numeric
},
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:numbers, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
types_with_type_and_value_test.rb 0000664 0000000 0000000 00000016542 14606620746 0041254 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success_and_failure/mixed # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: %i[numbers division_completed],
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:numbers, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
type_and_value_test.rb 0000664 0000000 0000000 00000016600 14606620746 0035662 0 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/expectations/without_source/success_and_failure # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: {
numbers: Array,
division_completed: Numeric
},
failure: {
invalid_arg: String,
division_by_zero: String
}
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:numbers, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success_and_failure/type_test.rb 0000664 0000000 0000000 00000015227 14606620746 0033727 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypeTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: :ok,
failure: :err
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:err, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:err, 'arg2 must be numeric')
Result::Success(:ok, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:ok, numbers) unless numbers.last.zero?
Result::Failure(:err, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:ok, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:ok)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:err)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:ok) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:err) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:ok) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:ok) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:err) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:err) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:division_completed)
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:division_by_zero)
end
assert_equal(
'type :division_by_zero is not allowed. Allowed types: :err',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:division_completed) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:invalid_arg) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :err',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :ok, :err',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:division_completed) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:division_by_zero) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:foo) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :division_completed is not allowed. Allowed types: :ok',
err1.message
)
assert_equal(
'type :division_by_zero is not allowed. Allowed types: :err',
err2.message
)
assert_equal(
'type :foo is not allowed. Allowed types: :ok, :err',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:ok) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:err) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:ok) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:err) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. This was not handled: :err',
err1.message
)
assert_equal(
'You must handle all cases. This was not handled: :err',
err2.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err3.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err4.message
)
assert_equal(
'You must handle all cases. This was not handled: :err',
err5.message
)
assert_equal(
'You must handle all cases. This was not handled: :ok',
err6.message
)
end
end
solid-result-2.0.0/test/solid/result/expectations/without_source/success_and_failure/types_test.rb 0000664 0000000 0000000 00000016453 14606620746 0034114 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypesTest < Minitest::Test
class Divide
Result = Solid::Result::Expectations.new(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
def call(arg1, arg2)
validate_numbers(arg1, arg2)
.and_then { |numbers| validate_non_zero(numbers) }
.and_then { |numbers| divide(numbers) }
end
private
def validate_numbers(arg1, arg2)
arg1.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Result::Failure(:invalid_arg, 'arg2 must be numeric')
Result::Success(:numbers, [arg1, arg2])
end
def validate_non_zero(numbers)
return Result::Success(:numbers, numbers) unless numbers.last.zero?
Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
Result::Success(:division_completed, number1 / number2)
end
end
test 'valid execution' do
result = Divide.new.call(10, 2)
assert result.success?(:division_completed)
assert_predicate result, :success?
# --
result = Divide.new.call(10, 0)
assert result.failure?(:division_by_zero)
assert_predicate result, :failure?
end
test 'valid hooks' do
increment = 0
result = Divide.new.call(10, 5)
result
.on_failure { increment += 1 }
.on_success { increment += 1 }
.on_success(:division_completed) { increment += 1 }
assert_equal 2, increment
# ---
decrement = 2
result = Divide.new.call(10, 0)
result
.on_success { decrement -= 1 }
.on_failure { decrement -= 1 }
.on_failure(:division_by_zero) { decrement -= 1 }
assert_equal 0, decrement
end
test 'valid handlers' do
increment = 0
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
end
Divide.new.call(10, 5).handle do |on|
on.failure { increment += 1 }
on.success(:numbers, :division_completed) { increment += 1 }
on.success { increment += 1 }
end
assert_equal 2, increment
# ---
decrement = 2
Divide.new.call(10, '2').handle do |on|
on.success { decrement -= 1 }
on.failure { decrement -= 1 }
on.failure(:invalid_arg, :division_by_zero) { decrement -= 1 }
end
Divide.new.call(10, '0').handle do |on|
on.success { decrement -= 1 }
on.failure(:invalid_arg) { decrement -= 1 }
on.failure { decrement -= 1 }
end
assert_equal 0, decrement
end
test 'invalid result type' do
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
assert_equal(
'type :invalid_arg is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
# ---
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
assert_equal(
'type :numbers is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
end
test 'invalid hooks' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'invalid handlers' do
result = Divide.new.call(6, 2)
err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.success(:ok) { :this_type_is_not_defined_in_the_expectations }
end
end
err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.failure(:err) { :this_type_is_not_defined_in_the_expectations }
end
end
err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.handle do |on|
on.type(:bar) { :this_type_is_not_defined_in_the_expectations }
end
end
assert_equal(
'type :ok is not allowed. Allowed types: :numbers, :division_completed',
err1.message
)
assert_equal(
'type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'type :bar is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero',
err3.message
)
end
test 'does not handle all cases' do
err1 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.success(:numbers) { :did_not_handle_all_expected_types }
end
end
err2 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, '2').handle do |on|
on.success { :did_not_handle_all_expected_types }
end
end
err3 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(8, '2').handle do |on|
on.failure { :did_not_handle_all_expected_types }
end
end
err4 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.failure(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
err5 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_completed) { :did_not_handle_all_expected_types }
end
end
err6 = assert_raises(Solid::Result::Error::UnhandledTypes) do
Divide.new.call(6, 2).handle do |on|
on.type(:division_by_zero) { :did_not_handle_all_expected_types }
end
end
assert_equal(
'You must handle all cases. These were not handled: :division_completed, :invalid_arg, :division_by_zero',
err1.message
)
assert_equal(
'You must handle all cases. These were not handled: :invalid_arg, :division_by_zero',
err2.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed',
err3.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err4.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :invalid_arg, :division_by_zero',
err5.message
)
assert_equal(
'You must handle all cases. These were not handled: :numbers, :division_completed, :invalid_arg',
err6.message
)
end
end
solid-result-2.0.0/test/solid/result/factories_test.rb 0000664 0000000 0000000 00000001675 14606620746 0023135 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::FactoriesTest < Minitest::Test
test '.Success() wihout a value' do
result = Solid::Result.Success(:ok)
assert result.success?(:ok)
assert_equal :ok, result.type
assert_nil result.value
end
test '.Success() with a value' do
value = [rand, 1, '1', [], {}].sample
result = Solid::Result.Success(:ok, value)
assert result.success?(:ok)
assert_equal :ok, result.type
assert_equal value, result.value
end
test '.Failure() wihout a value' do
result = Solid::Result.Failure(:err)
assert result.failure?(:err)
assert_equal :err, result.type
assert_nil result.value
end
test '.Failure() with a value' do
value = [rand, 2, '2', [], {}].sample
result = Solid::Result.Failure(:err, value)
assert result.failure?(:err)
assert_equal :err, result.type
assert_equal value, result.value
end
end
solid-result-2.0.0/test/solid/result/failure_test.rb 0000664 0000000 0000000 00000003545 14606620746 0022603 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class FailureTest < Minitest::Test
test 'is a Solid::Result' do
assert Failure < Solid::Result
end
test 'is a Solid::Failure' do
assert Failure < Solid::Failure
end
test '#terminal?' do
result = Failure.new(type: :err, value: nil)
assert_predicate result, :terminal?
end
test '#success? should return false' do
result = Failure.new(type: :err, value: nil)
refute_predicate result, :success?
refute result.success?(:err)
end
test '#failure? without receiving a type/argument' do
result = Failure.new(type: :bad, value: nil)
assert_predicate result, :failure?
end
test '#failure? receiving a type' do
result = Failure.new(type: :bad, value: nil)
assert result.failure?(:bad)
refute result.failure?(:err)
end
test '#type?' do
result = Failure.new(type: :bad, value: nil)
assert result.type?(:bad)
refute result.type?(:err)
end
test '#is?' do
result = Failure.new(type: :bad, value: nil)
assert result.is?(:bad)
refute result.is?(:err)
end
test '#method_missing' do
result = Failure.new(type: :bad, value: nil)
assert_respond_to result, :good?
assert_respond_to result, :bad?
end
test '#respond_to_missing?' do
result = Failure.new(type: :err, value: nil)
assert_predicate result, :err?
refute_predicate result, :ok?
assert_raises(NoMethodError) { result.ok }
end
test '#value_or' do
result = Failure.new(type: :err, value: nil)
assert_equal(0, result.value_or { 0 })
end
test '#inspect' do
result = Failure.new(type: :err, value: 2)
assert_equal '#', result.inspect
end
end
end
solid-result-2.0.0/test/solid/result/hooks/ 0000775 0000000 0000000 00000000000 14606620746 0020704 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/hooks/handle/ 0000775 0000000 0000000 00000000000 14606620746 0022137 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/hooks/handle/failure_test.rb 0000664 0000000 0000000 00000003243 14606620746 0025154 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class HandleFailureTest < Minitest::Test
test '#handle returns nil when there is no handler for the result' do
result = Failure.new(type: :foo, value: :bar)
outcome = result.handle do |on|
on.failure(:bar) { 1 }
on.success { 0 }
on[:baz] { 2 }
end
assert_nil outcome
end
test '#handle returns the value of the block when a handler matches the result type' do
result = Failure.new(type: :foo, value: :bar)
outcome1 = result.handle do |on|
on.success(:foo) { 0 }
on.failure { 1 }
end
assert_equal 1, outcome1
outcome2 = result.handle do |on|
on.success { 0 }
on[:foo] { 2 }
end
assert_equal 2, outcome2
outcome3 = result.handle do |on|
on.type(:foo) { 3 }
on.success { 0 }
end
assert_equal 3, outcome3
end
test '#handle matches even when the type is missing' do
result = Failure.new(type: :foo, value: :bar)
outcome = result.handle do |on|
on[:baz] { 3 }
on.failure { 2 }
on.failure(:foo) { 1 }
on.success { 0 }
end
assert_equal 2, outcome
end
test '#handle raises an error when type handler does not receive an argument' do
result = Failure.new(type: :foo, value: :bar)
error = assert_raises(Solid::Result::Error::MissingTypeArgument) do
result.handle do |on|
on.type { 1 }
end
end
assert_equal(
'A type (argument) is required to invoke the #on/#on_type method',
error.message
)
end
end
end
solid-result-2.0.0/test/solid/result/hooks/handle/success_test.rb 0000664 0000000 0000000 00000003243 14606620746 0025175 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class HandleSuccessTest < Minitest::Test
test '#handle returns nil when there is no handler for the result' do
result = Success.new(type: :foo, value: :bar)
outcome = result.handle do |on|
on.success(:bar) { 1 }
on.failure { 0 }
on[:baz] { 2 }
end
assert_nil outcome
end
test '#handle returns the value of the block when a handler matches the result type' do
result = Success.new(type: :foo, value: :bar)
outcome1 = result.handle do |on|
on.success(:foo) { 1 }
on.failure { 0 }
end
assert_equal 1, outcome1
outcome2 = result.handle do |on|
on.failure { 0 }
on[:foo] { 2 }
end
assert_equal 2, outcome2
outcome3 = result.handle do |on|
on.type(:foo) { 3 }
on.failure { 0 }
end
assert_equal 3, outcome3
end
test '#handle matches even when the type is missing' do
result = Success.new(type: :foo, value: :bar)
outcome = result.handle do |on|
on[:baz] { 3 }
on.success { 2 }
on.success(:foo) { 1 }
on.failure { 0 }
end
assert_equal 2, outcome
end
test '#handle raises an error when type handler does not receive an argument' do
result = Success.new(type: :foo, value: :bar)
error = assert_raises(Solid::Result::Error::MissingTypeArgument) do
result.handle do |on|
on.type { 1 }
end
end
assert_equal(
'A type (argument) is required to invoke the #on/#on_type method',
error.message
)
end
end
end
solid-result-2.0.0/test/solid/result/hooks/handle/unknown_test.rb 0000664 0000000 0000000 00000001727 14606620746 0025231 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class HandleUnknownTest < Minitest::Test
test '#handle ignores unknown when a success handler is called' do
result = Success.new(type: :foo, value: :bar)
outcome = result.handle do |on|
on.success { 1 }
on.unknown { raise }
end
assert_equal 1, outcome
end
test '#handle ignores unknown when a failure handler is called' do
result = Failure.new(type: :foo, value: :bar)
outcome = result.handle do |on|
on.failure { 0 }
on.unknown { raise }
end
assert_equal 0, outcome
end
test '#handle calls unknown handler when no other is called' do
result = Success.new(type: :foo, value: :bar)
outcome = result.handle do |on|
on[:bar] { raise }
on.success(:bar) { raise }
on.failure { raise }
on.unknown { 3 }
end
assert_equal 3, outcome
end
end
end
solid-result-2.0.0/test/solid/result/hooks/on_failure_test.rb 0000664 0000000 0000000 00000004474 14606620746 0024424 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class OnFailureHookTest < Minitest::Test
test '#on_failure returns the result itself' do
result = Failure.new(type: :error, value: 1)
r1 = result
.on_failure(:okay) { |value| assert_equal(1, value) }
r2 = result
.on_failure(:okay) { |value| assert_equal(1, value) }
.on_failure(:okay) { |value| assert_equal(1, value) }
assert_same result, r1
assert_same result, r2
end
test '#on_failure without receving types/arguments' do
number = 0
result = Failure.new(type: :error, value: 1)
result
.on_failure { |value| number += value }
.on_failure { |value| number += value }
result.on_failure { |value| number += value }
assert_equal 3, number
end
test '#on_failure with a single type' do
number = 0
result = Failure.new(type: :error, value: 1)
result
.on_failure { |value| number += value }
.on_failure(:error) { |value| number += value }
.on_failure(:error) { |value| number += value }
.on_failure(:wont_count) { |value| number += value }
.on_failure { |value| number += value }
assert_equal 4, number
end
test '#on_failure with multiple types' do
number = 0
result = Failure.new(type: :err, value: 1)
result
.on_failure(:not_okay, :err) { |value| number += value }
.on_failure { |value| number += value }
.on_failure(:err) { |value| number += value }
.on_failure(:not_okay, :wont_count) { |value| number += value }
.on_failure(:wont_count) { |value| number += value }
.on_failure { |value| number += value }
assert_equal 4, number
end
test '#on_failure without matching types' do
number = 0
result = Failure.new(type: :err, value: 1)
result
.on_failure(:not_okay) { |value| number += value }
.on_failure(:error) { |value| number += value }
assert_equal 0, number
end
test '#on_failure is ignored by successes' do
number = 0
result = Success.new(type: :ok, value: 1)
result
.on_failure { |value| number += value }
.on_failure(:ok) { |value| number += value }
assert_equal 0, number
end
end
end
solid-result-2.0.0/test/solid/result/hooks/on_success_test.rb 0000664 0000000 0000000 00000004446 14606620746 0024444 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class OnSuccessHookTest < Minitest::Test
test '#on_success returns the result itself' do
result = Success.new(type: :okay, value: 1)
r1 = result
.on_success(:okay) { |value| assert_equal(1, value) }
r2 = result
.on_success(:okay) { |value| assert_equal(1, value) }
.on_success(:okay) { |value| assert_equal(1, value) }
assert_same result, r1
assert_same result, r2
end
test '#on_success without receving types/arguments' do
number = 0
result = Success.new(type: :okay, value: 1)
result
.on_success { |value| number += value }
.on_success { |value| number += value }
result.on_success { |value| number += value }
assert_equal 3, number
end
test '#on_success with a single type' do
number = 0
result = Success.new(type: :okay, value: 1)
result
.on_success { |value| number += value }
.on_success(:okay) { |value| number += value }
.on_success(:okay) { |value| number += value }
.on_success(:wont_count) { |value| number += value }
.on_success { |value| number += value }
assert_equal 4, number
end
test '#on_success with multiple types' do
number = 0
result = Success.new(type: :ok, value: 1)
result
.on_success(:okay, :ok) { |value| number += value }
.on_success { |value| number += value }
.on_success(:okay) { |value| number += value }
.on_success(:ok, :wont_count) { |value| number += value }
.on_success(:wont_count) { |value| number += value }
.on_success { |value| number += value }
assert_equal 4, number
end
test '#on_success without matching types' do
number = 0
result = Success.new(type: :ok, value: 1)
result
.on_success(:yes) { |value| number += value }
.on_success(:okay) { |value| number += value }
assert_equal 0, number
end
test '#on_success is ignored by failures' do
number = 0
result = Failure.new(type: :err, value: 0)
result
.on_success { |value| number += value }
.on_success(:err) { |value| number += value }
assert_equal 0, number
end
end
end
solid-result-2.0.0/test/solid/result/hooks/on_test.rb 0000664 0000000 0000000 00000003615 14606620746 0022711 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class OnHookTest < Minitest::Test
test '#on returns the result itself' do
result = Success.new(type: :okay, value: 1)
r1 = result.on(:okay) { |value| assert_equal(1, value) }
r2 =
result
.on(:okay) { |value| assert_equal(1, value) }
.on(:okay) { |value| assert_equal(1, value) }
assert_same result, r1
assert_same result, r2
end
test '#on works with successes or failures' do
number = 0
success = Success.new(type: :foo, value: 1)
failure = Failure.new(type: :foo, value: 2)
success.on(:foo) { |value| number += value }
failure.on(:foo) { |value| number += value }
assert_equal 3, number
end
test '#on without receving types/arguments' do
number = 0
result = Success.new(type: :okay, value: 1)
error = assert_raises(Solid::Result::Error::MissingTypeArgument) do
result.on { |value| number += value }
end
assert_equal(
'A type (argument) is required to invoke the #on/#on_type method',
error.message
)
end
test '#on with a single type' do
number = 0
result = Success.new(type: :okay, value: 1)
result
.on(:okay) { |value| number += value }
.on(:ok) { |value| number += value }
assert_equal 1, number
end
test '#on with multiple types' do
number = 0
result = Success.new(type: :ok, value: 1)
result
.on(:ok) { |value| number += value }
.on(:okay, :ok) { |value| number += value }
assert_equal 2, number
end
test '#on without matching types' do
number = 0
result = Success.new(type: :ok, value: 1)
result
.on(:okay) { |value| number += value }
.on(:err) { |value| number += value }
assert_equal 0, number
end
end
end
solid-result-2.0.0/test/solid/result/hooks/on_type_test.rb 0000664 0000000 0000000 00000000633 14606620746 0023747 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class OnTypeHookTest < Minitest::Test
test '#on_type is an alias for #on' do
success = Success.new(type: :okay, value: 1)
failure = Failure.new(type: :nokay, value: nil)
assert_equal success.method(:on), success.method(:on_type)
assert_equal failure.method(:on), failure.method(:on_type)
end
end
end
solid-result-2.0.0/test/solid/result/hooks/on_unknown_test.rb 0000664 0000000 0000000 00000003662 14606620746 0024472 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class OnUnknownHookTest < Minitest::Test
test '#on_unknown is ignored when a success hook is called' do
Success
.new(type: :bar, value: :foo)
.on_success { |value| assert_equal(:foo, value) }
.on_unknown { raise }
Success
.new(type: :bar, value: :foo)
.on_success(:bar) { |value| assert_equal(:foo, value) }
.on_unknown { raise }
end
test '#on_unknown is ignored when a failure hook is called' do
Failure
.new(type: :bar, value: :foo)
.on_failure { |value| assert_equal(:foo, value) }
.on_unknown { raise }
Failure
.new(type: :bar, value: :foo)
.on_failure(:bar) { |value| assert_equal(:foo, value) }
.on_unknown { raise }
end
test '#on_unknown is called when no other hook is called' do
number = 0
Success
.new(type: :bar, value: :foo)
.on(:foo) { raise }
.on_success(:foo) { raise }
.on_failure { raise }
.on_unknown { number += 1 }
Failure
.new(type: :bar, value: :foo)
.on(:foo) { raise }
.on_success { raise }
.on_unknown { number += 1 }
assert_equal 2, number
end
test '#on_unknown returns the result itself' do
failure = Failure.new(type: :error, value: 0)
r1 = failure
.on_unknown { |value| assert_equal(0, value) }
r2 = failure
.on_success { |value| assert_equal(0, value) }
.on_unknown { |value| assert_equal(0, value) }
assert_same failure, r1
assert_same failure, r2
# --
success = Success.new(type: :ok, value: 1)
r3 = success
.on_unknown { |value| assert_equal(1, value) }
r4 = success
.on_failure { |value| assert_equal(1, value) }
assert_same success, r3
assert_same success, r4
end
end
end
solid-result-2.0.0/test/solid/result/mixin_constants_test.rb 0000664 0000000 0000000 00000001307 14606620746 0024366 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::MixinConstantsTest < Minitest::Test
class IncludingInClass
include Solid::Result.mixin
end
module IncludingInModule
include Solid::Result.mixin
end
class ExtendingInClass
extend Solid::Result.mixin
end
module ExtendingInModule
extend Solid::Result.mixin
end
test 'Solid::Result.mixin sets a constant in all classes/modules' do
assert IncludingInClass.const_defined?(:ResultMixin, false)
assert IncludingInModule.const_defined?(:ResultMixin, false)
assert ExtendingInClass.const_defined?(:ResultMixin, false)
assert ExtendingInModule.const_defined?(:ResultMixin, false)
end
end
solid-result-2.0.0/test/solid/result/pattern_matching/ 0000775 0000000 0000000 00000000000 14606620746 0023110 5 ustar 00root root 0000000 0000000 solid-result-2.0.0/test/solid/result/pattern_matching/deconstruct_keys_test.rb 0000664 0000000 0000000 00000002773 14606620746 0030075 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::PatternMatchingDeconstructKeysTest < Minitest::Test
Divide = ->(arg1, arg2) do
arg1.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Solid::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Solid::Result::Success(:division_completed, arg1 / arg2)
end
test '#deconstruct_keys success' do
result = Divide.call(10, 2)
assert_equal(5, result.deconstruct_keys([]))
case result
in Solid::Failure(type: _, value: _)
raise
in Solid::Success(type: :division_completed, value: value)
assert_equal 5, value
end
case result
in Solid::Result::Failure(type: _, value: _)
raise
in Solid::Result::Success(type: :division_completed, value: value)
assert_equal 5, value
end
end
test '#deconstruct_keys failure' do
result = Divide.call(10, 0)
assert_equal('arg2 must not be zero', result.deconstruct_keys([]))
case result
in Solid::Success(type: _, value: _)
raise
in Solid::Failure(type: :division_by_zero, value: msg)
assert_equal 'arg2 must not be zero', msg
end
case result
in Solid::Result::Success(type: _, value: _)
raise
in Solid::Result::Failure(type: :division_by_zero, value: msg)
assert_equal 'arg2 must not be zero', msg
end
end
end
solid-result-2.0.0/test/solid/result/pattern_matching/deconstruct_test.rb 0000664 0000000 0000000 00000002635 14606620746 0027037 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::PatternMatchingDeconstructTest < Minitest::Test
Divide = ->(arg1, arg2) do
arg1.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg1 must be numeric')
arg2.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg, 'arg2 must be numeric')
return Solid::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
Solid::Result::Success(:division_completed, arg1 / arg2)
end
test '#deconstruct success' do
result = Divide.call(10, 2)
assert_equal [:division_completed, 5], result.deconstruct
case result
in Solid::Failure[_, _]
raise
in Solid::Success[:division_completed, value]
assert_equal 5, value
end
case result
in Solid::Result::Failure[_, _]
raise
in Solid::Result::Success[:division_completed, value]
assert_equal 5, value
end
end
test '#deconstruct failure' do
result = Divide.call(10, 0)
assert_equal [:division_by_zero, 'arg2 must not be zero'], result.deconstruct
case result
in Solid::Success[_, _]
raise
in Solid::Failure[:division_by_zero, msg]
assert_equal 'arg2 must not be zero', msg
end
case result
in Solid::Result::Success[_, _]
raise
in Solid::Result::Failure[:division_by_zero, msg]
assert_equal 'arg2 must not be zero', msg
end
end
end
solid-result-2.0.0/test/solid/result/success_test.rb 0000664 0000000 0000000 00000003547 14606620746 0022626 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result
class SuccessTest < Minitest::Test
test 'is a Solid::Result' do
assert Success < Solid::Result
end
test 'is a Solid::Success' do
assert Success < Solid::Success
end
test '#terminal?' do
result = Success.new(type: :ok, value: nil)
refute_predicate result, :terminal?
end
test '#success? without receiving a type/argument' do
result = Success.new(type: :good, value: nil)
assert_predicate result, :success?
end
test '#success? receiving a type' do
result = Success.new(type: :good, value: nil)
assert result.success?(:good)
refute result.success?(:ok)
end
test '#failure? should return false' do
result = Success.new(type: :ok, value: nil)
refute_predicate result, :failure?
refute result.failure?(:ok)
end
test '#type?' do
result = Success.new(type: :good, value: nil)
assert result.type?(:good)
refute result.type?(:ok)
end
test '#is?' do
result = Success.new(type: :good, value: nil)
assert result.is?(:good)
refute result.is?(:ok)
end
test '#method_missing' do
result = Success.new(type: :good, value: nil)
assert_predicate result, :good?
refute_predicate result, :bad?
assert_raises(NoMethodError) { result.good }
end
test '#respond_to_missing?' do
result = Success.new(type: :good, value: nil)
assert_respond_to result, :good?
assert_respond_to result, :bad?
end
test '#value_or' do
result = Success.new(type: :ok, value: 1)
assert_equal(1, result.value_or { 0 })
end
test '#inspect' do
result = Success.new(type: :ok, value: 2)
assert_equal '#', result.inspect
end
end
end
solid-result-2.0.0/test/solid/result/version_test.rb 0000664 0000000 0000000 00000000303 14606620746 0022626 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
class Solid::Result::VersionTest < Minitest::Test
test 'should have a version number' do
refute_nil ::Solid::Result::VERSION
end
end
solid-result-2.0.0/test/solid/result_test.rb 0000664 0000000 0000000 00000005633 14606620746 0021154 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'test_helper'
module Solid
class ResultTest < Minitest::Test
test '#initialize errors' do
error1 = assert_raises(ArgumentError) { Result.new(type: :ok) }
error2 = assert_raises(ArgumentError) { Result.new(value: 1) }
error3 = assert_raises(ArgumentError) { Result.new }
assert_equal 'missing keyword: :value', error1.message
assert_equal 'missing keyword: :type', error2.message
assert_equal 'missing keywords: :type, :value', error3.message
end
test '#value' do
assert_equal 1, Result.new(type: :ok, value: 1).value
assert_nil Result.new(type: :ok, value: nil).value
end
test '#type' do
assert_equal :ok, Result.new(type: :ok, value: 1).type
assert_equal :yes, Result.new(type: :yes, value: nil).type
assert_equal :err, Result.new(type: :err, value: 0).type
assert_equal :no, Result.new(type: :no, value: nil).type
end
test '#success?' do
result = Result.new(type: :ok, value: 1)
assert_raises(Solid::Result::Error::NotImplemented) { result.success? }
assert_raises(Solid::Result::Error::NotImplemented) { result.success?(:ok) }
end
test '#failure?' do
result = Result.new(type: :err, value: 0)
assert_raises(Solid::Result::Error::NotImplemented) { result.failure? }
assert_raises(Solid::Result::Error::NotImplemented) { result.failure?(:err) }
end
test '#terminal?' do
result = Result.new(type: :err, value: 0)
refute_predicate(result, :terminal?)
end
test '#value_or' do
result = Result.new(type: :ok, value: 1)
assert_raises(Solid::Result::Error::NotImplemented) { result.value_or { 0 } }
end
test '#deconstruct' do
result = Result.new(type: :ok, value: 1)
assert_equal([:ok, 1], result.deconstruct)
end
test '#deconstruct_keys' do
result = Result.new(type: :ok, value: 1)
assert_equal(1, result.deconstruct_keys([]))
end
test '#==' do
result = Result.new(type: :ok, value: 2)
assert_equal result, Result.new(type: :ok, value: 2)
refute_equal result, Result.new(type: :ok, value: 3)
refute_equal result, Result.new(type: :yes, value: 2)
end
test '#eql?' do
result = Result.new(type: :ok, value: 2)
assert result.eql?(Result.new(type: :ok, value: 2))
refute result.eql?(Result.new(type: :ok, value: 3))
refute result.eql?(Result.new(type: :yes, value: 2))
end
test '#hash' do
result = Result.new(type: :ok, value: 2)
assert_equal result.hash, Result.new(type: :ok, value: 2).hash
refute_equal result.hash, Result.new(type: :ok, value: 3).hash
refute_equal result.hash, Result.new(type: :yes, value: 2).hash
end
test '#inspect' do
result = Result.new(type: :ok, value: 2)
assert_equal '#', result.inspect
end
end
end
solid-result-2.0.0/test/test_helper.rb 0000664 0000000 0000000 00000011657 14606620746 0020006 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require 'simplecov'
SimpleCov.start do
enable_coverage :branch
add_filter '_test.rb'
end
$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
require 'solid/result'
require 'minitest/autorun'
require 'mocha/minitest'
class Minitest::Test
# Implementation based on:
# https://github.com/rails/rails/blob/ac717d6/activesupport/lib/active_support/testing/declarative.rb
def self.test(name, &block)
test_name = :"test_#{name.gsub(/\s+/, '_')}"
method_defined?(test_name) and raise "#{test_name} is already defined in #{self}"
if block
define_method(test_name, &block)
else
define_method(test_name) do
flunk "No implementation provided for #{name}"
end
end
end
end
module HashSchemaAssertions
def assert_hash_schema!(spec, hash, ignore_keys: [])
keys_to_compare = hash.keys - ignore_keys
assert_collection_diff(spec.keys, keys_to_compare, context_message: nil)
spec.each { |key, expected| assert_hash_schema_item(expected, key, hash[key]) }
end
def assert_hash_schema(spec, hash)
keys_diff = spec.keys - hash.keys
ignore_keys = hash.keys - spec.keys
assert_empty(keys_diff, "Keys expected in the diff #{keys_diff}")
assert_hash_schema!(spec, hash, ignore_keys: ignore_keys)
end
private
ErrorMessage = ->(key, extra = nil) { "The key #{key.inspect} has an invalid value. #{extra}".chomp(' ') }
def assert_hash_schema_item(expected, key, value)
case expected
when Hash then assert_hash_schema!(expected, value)
when Proc then assert(expected.call(value), ErrorMessage[key])
when Regexp then assert_match(expected, value, ErrorMessage[key])
when Module then assert_kind_of(expected, value, ErrorMessage[key])
when NilClass then assert_nil(value, ErrorMessage[key])
when Array, Set then assert_hash_schema_item_collection(expected, value, ErrorMessage[key])
else
assert_equal(expected, value, ErrorMessage[key])
end
end
def assert_hash_schema_item_collection(expected, value, error_message)
assert_collection_diff(expected.to_a, value.to_a, context_message: error_message)
expected.each do |item|
item.is_a?(Hash) ? assert_hash_schema!(item, value) : assert_includes(value, item, error_message)
end
end
def assert_collection_diff(expected, actual, context_message:)
context = "(#{context_message}) " if context_message
actual_diff = actual - expected
expected_diff = expected - actual
assert_empty(actual_diff, "#{context}Keys expected in the diff: #{actual_diff}")
assert_empty(expected_diff, "#{context}Keys not expected in the diff: #{expected_diff}")
end
end
module SolidResultEventLogAssertions
include HashSchemaAssertions
def assert_empty_event_logs(result, version: 1)
assert_event_logs(result, size: 0, version: version)
assert_predicate(result.event_logs, :frozen?)
assert_predicate(result.event_logs[:records], :frozen?)
end
def assert_event_logs(result, size:, version: 1, trace_id: nil)
assert_event_logs!(result.event_logs, size: size, version: version, trace_id: trace_id)
end
def assert_event_logs!(event_logs, size:, version: 1, trace_id: nil)
assert_instance_of(Hash, event_logs)
assert_equal(%i[metadata records version], event_logs.keys.sort)
assert_equal(version, event_logs[:version])
assert_equal(size, event_logs[:records].size)
assert_event_logs_metadata(event_logs, trace_id)
end
def assert_event_logs_metadata(event_logs, trace_id)
assert_instance_of(Hash, event_logs[:metadata])
metadata = event_logs[:metadata]
assert_equal(%i[duration ids trace_id], metadata.keys.sort)
assert_instance_of(Integer, metadata[:duration])
assert_event_logs_metadata_ids(metadata)
assert_event_logs_metadata_trace_id(metadata, trace_id)
end
def assert_event_logs_metadata_trace_id(metadata, trace_id)
metadata_trace_id = metadata[:trace_id]
trace_id.nil? ? assert_nil(metadata_trace_id) : assert_equal(trace_id, metadata_trace_id)
end
def assert_event_logs_metadata_ids(metadata)
assert_instance_of(Hash, metadata[:ids])
assert_instance_of(Array, metadata[:ids][:tree])
assert_instance_of(Hash, metadata[:ids][:matrix])
assert_instance_of(Hash, metadata[:ids][:level_parent])
end
TimeValue = ->(value) { value.is_a?(::Time) && value.utc? }
AndThenValue = ->(value) { value.is_a?(::Hash) && value.empty? }
def assert_event_log_record(result, index, options)
event_log = result.event_logs[:records][index]
root, parent, current, result_data = options.fetch_values(:root, :parent, :current, :result)
result_data[:source] = result.send(:source) unless result_data.key?(:source)
and_then = options.fetch(:and_then) { AndThenValue }
time = options.fetch(:time) { TimeValue }
assert_hash_schema!(
{ root: root, parent: parent, current: current, result: result_data, and_then: and_then, time: time },
event_log
)
end
end